OpenGL (Windows): support EGL via ANGLE

Author: CarterLi

CMakeLists.txt

@@ -61,7 +61,7 @@ cmake_dependent_option(ENABLE_IMAGEMAGICK7 "Enable imagemagick 7" ON "LINUX OR B
 cmake_dependent_option(ENABLE_IMAGEMAGICK6 "Enable imagemagick 6" ON "LINUX OR BSD OR APPLE OR SunOS" OFF)
 cmake_dependent_option(ENABLE_CHAFA "Enable chafa" ON "ENABLE_IMAGEMAGICK6 OR ENABLE_IMAGEMAGICK7" OFF)
 cmake_dependent_option(ENABLE_ZLIB "Enable zlib" ON "ENABLE_IMAGEMAGICK6 OR ENABLE_IMAGEMAGICK7" OFF)
-cmake_dependent_option(ENABLE_EGL "Enable egl" ON "LINUX OR BSD OR SunOS" OFF)
+cmake_dependent_option(ENABLE_EGL "Enable egl" ON "LINUX OR BSD OR WIN32 OR SunOS" OFF)
 cmake_dependent_option(ENABLE_GLX "Enable glx" ON "LINUX OR BSD OR SunOS" OFF)
 cmake_dependent_option(ENABLE_OSMESA "Enable osmesa" ON "LINUX OR BSD OR SunOS" OFF)
 cmake_dependent_option(ENABLE_OPENCL "Enable opencl" ON "LINUX OR BSD OR WIN32 OR ANDROID OR SunOS" OFF)
@@ -307,6 +307,7 @@ set(LIBFASTFETCH_SRC
     src/detection/media/media.c
     src/detection/netio/netio.c
     src/detection/opencl/opencl.c
+    src/detection/opengl/opengl_shared.c
     src/detection/os/os.c
     src/detection/packages/packages.c
     src/detection/physicalmemory/physicalmemory.c

src/detection/opengl/opengl.h

@@ -11,4 +11,7 @@ typedef struct FFOpenGLResult
     FFstrbuf library;
 } FFOpenGLResult;
 
+#define FF_OPENGL_BUFFER_WIDTH 1
+#define FF_OPENGL_BUFFER_HEIGHT 1
+
 const char* ffDetectOpenGL(FFOpenGLOptions* options, FFOpenGLResult* result);

src/detection/opengl/opengl_apple.c

@@ -6,24 +6,18 @@
 #include <OpenGL/gl.h>
 #include <OpenGL/OpenGL.h> // This brings in CGL, not GL
 
-static void glHandleResult(FFOpenGLResult* result)
-{
-    ffStrbufAppendS(&result->version, (const char*) glGetString(GL_VERSION));
-    ffStrbufAppendS(&result->renderer, (const char*) glGetString(GL_RENDERER));
-    ffStrbufAppendS(&result->vendor, (const char*) glGetString(GL_VENDOR));
-    ffStrbufAppendS(&result->slv, (const char*) glGetString(GL_SHADING_LANGUAGE_VERSION));
-
-    GLint major, minor;
-    CGLGetVersion(&major, &minor);
-    ffStrbufAppendF(&result->library, "CGL %d.%d", major, minor);
-}
+void ffOpenGLHandleResult(FFOpenGLResult* result, __typeof__(&glGetString) ffglGetString);
 
 static const char* cglHandleContext(FFOpenGLResult* result, CGLContextObj context)
 {
     if(CGLSetCurrentContext(context) != kCGLNoError)
         return "CGLSetCurrentContext() failed";
 
-    glHandleResult(result);
+    ffOpenGLHandleResult(result, &glGetString);
+
+    GLint major, minor;
+    CGLGetVersion(&major, &minor);
+    ffStrbufSetF(&result->library, "CGL %d.%d", major, minor);
 
     return NULL;
 }

src/detection/opengl/opengl_linux.c

@@ -10,147 +10,17 @@
 
 #include <GL/gl.h>
 
-#define FF_OPENGL_BUFFER_WIDTH 1
-#define FF_OPENGL_BUFFER_HEIGHT 1
-
-typedef struct GLData
-{
-    FF_LIBRARY_SYMBOL(glGetString)
-} GLData;
-
-static void glHandleResult(FFOpenGLResult* result, const GLData* data)
-{
-    ffStrbufAppendS(&result->version, (const char*) data->ffglGetString(GL_VERSION));
-    ffStrbufAppendS(&result->renderer, (const char*) data->ffglGetString(GL_RENDERER));
-    ffStrbufAppendS(&result->vendor, (const char*) data->ffglGetString(GL_VENDOR));
-    ffStrbufAppendS(&result->slv, (const char*) data->ffglGetString(GL_SHADING_LANGUAGE_VERSION));
-}
+void ffOpenGLHandleResult(FFOpenGLResult* result, __typeof__(&glGetString) ffglGetString);
 
 #endif // FF_HAVE_GL
 
-#ifdef FF_HAVE_EGL
-#include "common/io/io.h"
-
-#include <EGL/egl.h>
-
-typedef struct EGLData
-{
-    GLData glData;
-
-    FF_LIBRARY_SYMBOL(eglGetProcAddress)
-    FF_LIBRARY_SYMBOL(eglGetDisplay)
-    FF_LIBRARY_SYMBOL(eglQueryString)
-    FF_LIBRARY_SYMBOL(eglInitialize)
-    FF_LIBRARY_SYMBOL(eglBindAPI)
-    FF_LIBRARY_SYMBOL(eglGetConfigs)
-    FF_LIBRARY_SYMBOL(eglCreatePbufferSurface)
-    FF_LIBRARY_SYMBOL(eglCreateContext)
-    FF_LIBRARY_SYMBOL(eglMakeCurrent)
-    FF_LIBRARY_SYMBOL(eglDestroyContext)
-    FF_LIBRARY_SYMBOL(eglDestroySurface)
-    FF_LIBRARY_SYMBOL(eglTerminate)
-
-    EGLDisplay display;
-    EGLConfig config;
-    EGLSurface surface;
-    EGLContext context;
-} EGLData;
-
-static const char* eglHandleContext(FFOpenGLResult* result, EGLData* data)
-{
-    if(data->ffeglMakeCurrent(data->display, data->surface, data->surface, data->context) != EGL_TRUE)
-        return "eglMakeCurrent returned EGL_FALSE";
-
-    glHandleResult(result, &data->glData);
-    ffStrbufSetF(&result->library, "EGL %s", data->ffeglQueryString(data->display, EGL_VERSION));
-    return NULL;
-}
-
-static const char* eglHandleSurface(FFOpenGLResult* result, EGLData* data)
-{
-    data->context = data->ffeglCreateContext(data->display, data->config, EGL_NO_CONTEXT, (EGLint[]){EGL_NONE});
-    if(data->context == EGL_NO_CONTEXT)
-        return "eglCreateContext returned EGL_NO_CONTEXT";
-
-    const char* error = eglHandleContext(result, data);
-    data->ffeglDestroyContext(data->display, data->context);
-    return error;
-}
-
-static const char* eglHandleDisplay(FFOpenGLResult* result, EGLData* data)
-{
-    if(data->ffeglBindAPI(EGL_OPENGL_API) != EGL_TRUE)
-        return "eglBindAPI returned EGL_FALSE";
-
-    EGLint eglConfigCount;
-    data->ffeglGetConfigs(data->display, &data->config, 1, &eglConfigCount);
-    if(eglConfigCount == 0)
-        return "eglGetConfigs returned 0 configs";
-
-    data->surface = data->ffeglCreatePbufferSurface(data->display, data->config, (EGLint[]){
-        EGL_WIDTH, FF_OPENGL_BUFFER_WIDTH,
-        EGL_HEIGHT, FF_OPENGL_BUFFER_HEIGHT,
-        EGL_NONE
-    });
-
-    if(data->surface == EGL_NO_SURFACE)
-        return "eglCreatePbufferSurface returned EGL_NO_SURFACE";
-
-    const char* error = eglHandleSurface(result, data);
-    data->ffeglDestroySurface(data->display, data->surface);
-    return error;
-}
-
-static const char* eglHandleData(FFOpenGLResult* result, EGLData* data)
-{
-    data->glData.ffglGetString = (__typeof__(data->glData.ffglGetString)) data->ffeglGetProcAddress("glGetString");
-    if(!data->glData.ffglGetString)
-        return "eglGetProcAddress(glGetString) returned NULL";
-
-    data->display = data->ffeglGetDisplay(EGL_DEFAULT_DISPLAY);
-    if(data->display == EGL_NO_DISPLAY)
-        return "eglGetDisplay returned EGL_NO_DISPLAY";
-
-    EGLint major, minor;
-    if(data->ffeglInitialize(data->display, &major, &minor) == EGL_FALSE)
-        return "eglInitialize returned EGL_FALSE";
-
-    const char* error = eglHandleDisplay(result, data);
-    data->ffeglTerminate(data->display);
-    return error;
-}
-
-static const char* eglPrint(FFOpenGLResult* result)
-{
-    EGLData eglData;
-
-    FF_LIBRARY_LOAD(egl, &instance.config.library.libEGL, "dlopen egl failed", "libEGL" FF_LIBRARY_EXTENSION, 1);
-    FF_LIBRARY_LOAD_SYMBOL_VAR_MESSAGE(egl, eglData, eglGetProcAddress);
-    FF_LIBRARY_LOAD_SYMBOL_VAR_MESSAGE(egl, eglData, eglGetDisplay);
-    FF_LIBRARY_LOAD_SYMBOL_VAR_MESSAGE(egl, eglData, eglQueryString);
-    FF_LIBRARY_LOAD_SYMBOL_VAR_MESSAGE(egl, eglData, eglInitialize);
-    FF_LIBRARY_LOAD_SYMBOL_VAR_MESSAGE(egl, eglData, eglBindAPI);
-    FF_LIBRARY_LOAD_SYMBOL_VAR_MESSAGE(egl, eglData, eglGetConfigs);
-    FF_LIBRARY_LOAD_SYMBOL_VAR_MESSAGE(egl, eglData, eglCreatePbufferSurface);
-    FF_LIBRARY_LOAD_SYMBOL_VAR_MESSAGE(egl, eglData, eglCreateContext);
-    FF_LIBRARY_LOAD_SYMBOL_VAR_MESSAGE(egl, eglData, eglMakeCurrent);
-    FF_LIBRARY_LOAD_SYMBOL_VAR_MESSAGE(egl, eglData, eglDestroyContext);
-    FF_LIBRARY_LOAD_SYMBOL_VAR_MESSAGE(egl, eglData, eglDestroySurface);
-    FF_LIBRARY_LOAD_SYMBOL_VAR_MESSAGE(egl, eglData, eglTerminate);
-
-    FF_SUPPRESS_IO();
-    return eglHandleData(result, &eglData);
-}
-
-#endif //FF_HAVE_EGL
 
 #ifdef FF_HAVE_GLX
 #include <GL/glx.h>
 
 typedef struct GLXData
 {
-    GLData glData;
-
+    FF_LIBRARY_SYMBOL(glGetString)
     FF_LIBRARY_SYMBOL(glXGetProcAddress)
     FF_LIBRARY_SYMBOL(glXQueryVersion)
     FF_LIBRARY_SYMBOL(XOpenDisplay)
@@ -176,7 +46,7 @@ static const char* glxHandleContext(FFOpenGLResult* result, GLXData* data)
 {
     if(data->ffglXMakeCurrent(data->display, data->glxPixmap, data->context) != True)
         return "glXMakeCurrent returned False";
-    glHandleResult(result, &data->glData);
+    ffOpenGLHandleResult(result, data->ffglGetString);
 
     int major, minor;
     if (data->ffglXQueryVersion(data->display, &major, &minor))
@@ -233,8 +103,8 @@ static const char* glxHandleDisplay(FFOpenGLResult* result, GLXData* data)
 
 static const char* glxHandleData(FFOpenGLResult* result, GLXData* data)
 {
-    data->glData.ffglGetString = (__typeof__(data->glData.ffglGetString)) data->ffglXGetProcAddress((const GLubyte*) "glGetString");
-    if(data->glData.ffglGetString == NULL)
+    data->ffglGetString = (__typeof__(data->ffglGetString)) data->ffglXGetProcAddress((const GLubyte*) "glGetString");
+    if(data->ffglGetString == NULL)
         return "glXGetProcAddress(glGetString) returned NULL";
 
     data->display = data->ffXOpenDisplay(NULL);
@@ -246,7 +116,7 @@ static const char* glxHandleData(FFOpenGLResult* result, GLXData* data)
     return error;
 }
 
-static const char* glxPrint(FFOpenGLResult* result)
+static const char* detectByGlx(FFOpenGLResult* result)
 {
     GLXData data;
 
@@ -279,8 +149,7 @@ static const char* glxPrint(FFOpenGLResult* result)
 
 typedef struct OSMesaData
 {
-    GLData glData;
-
+    FF_LIBRARY_SYMBOL(glGetString)
     FF_LIBRARY_SYMBOL(OSMesaGetProcAddress)
     FF_LIBRARY_SYMBOL(OSMesaCreateContext)
     FF_LIBRARY_SYMBOL(OSMesaMakeCurrent)
@@ -296,16 +165,15 @@ static const char* osMesaHandleContext(FFOpenGLResult* result, OSMesaData* data)
     if(data->ffOSMesaMakeCurrent(data->context, buffer, GL_UNSIGNED_BYTE, FF_OPENGL_BUFFER_WIDTH, FF_OPENGL_BUFFER_HEIGHT) != GL_TRUE)
         return "OSMesaMakeCurrent returned GL_FALSE";
 
-    glHandleResult(result, &data->glData);
+    ffOpenGLHandleResult(result, data->ffglGetString);
     ffStrbufSetF(&result->library, "OSMesa %d.%d.%d", OSMESA_MAJOR_VERSION, OSMESA_MINOR_VERSION, OSMESA_PATCH_VERSION);
     return NULL;
 }
 
 static const char* osMesaHandleData(FFOpenGLResult* result, OSMesaData* data)
 {
-    //The case to void* is required here, because OSMESAproc can't be cast to (__typeof__(data->glData.ffglGetString)) without a warning, even though it is the actual type.
-    data->glData.ffglGetString = (__typeof__(data->glData.ffglGetString)) (void*) data->ffOSMesaGetProcAddress("glGetString");
-    if(data->glData.ffglGetString == NULL)
+    data->ffglGetString = (void*) data->ffOSMesaGetProcAddress("glGetString");
+    if(data->ffglGetString == NULL)
         return "OSMesaGetProcAddress(glGetString) returned NULL";
 
     data->context = data->ffOSMesaCreateContext(OSMESA_RGBA, NULL);
@@ -317,7 +185,7 @@ static const char* osMesaHandleData(FFOpenGLResult* result, OSMesaData* data)
     return error;
 }
 
-static const char* osMesaPrint(FFOpenGLResult* result)
+static const char* detectByOsMesa(FFOpenGLResult* result)
 {
     OSMesaData data;
 
@@ -339,7 +207,7 @@ const char* ffDetectOpenGL(FFOpenGLOptions* options, FFOpenGLResult* result)
     if(options->library == FF_OPENGL_LIBRARY_GLX)
     {
         #ifdef FF_HAVE_GLX
-            return glxPrint(result);
+            return detectByGlx(result);
         #else
             return "fastfetch was compiled without glx support";
         #endif
@@ -348,7 +216,8 @@ const char* ffDetectOpenGL(FFOpenGLOptions* options, FFOpenGLResult* result)
     if(options->library == FF_OPENGL_LIBRARY_EGL)
     {
         #ifdef FF_HAVE_EGL
-            return eglPrint(result);
+            const char* ffOpenGLDetectByEGL(FFOpenGLResult* result);
+            return ffOpenGLDetectByEGL(result);
         #else
             return "fastfetch was compiled without egl support";
         #endif
@@ -357,7 +226,7 @@ const char* ffDetectOpenGL(FFOpenGLOptions* options, FFOpenGLResult* result)
     if(options->library == FF_OPENGL_LIBRARY_OSMESA)
     {
         #ifdef FF_HAVE_OSMESA
-            return osMesaPrint(result);
+            return detectByOsMesa(result);
         #else
             return "fastfetch was compiled without osmesa support";
         #endif
@@ -366,12 +235,13 @@ const char* ffDetectOpenGL(FFOpenGLOptions* options, FFOpenGLResult* result)
     const char* error = ""; // not NULL dummy value
 
     #ifdef FF_HAVE_EGL
-        error = eglPrint(result);
+        const char* ffOpenGLDetectByEGL(FFOpenGLResult* result);
+        error = ffOpenGLDetectByEGL(result);
     #endif
 
     #ifdef FF_HAVE_GLX
         if(error != NULL)
-            error = glxPrint(result);
+            error = detectByGlx(result);
     #endif
 
     //We don't use osmesa in auto mode here, because it is a software implementation,