EGLContext.cpp

#ifdef COGS_EGL
 
#include "GLFuncPointers.h"
#include "GLContext.h"
 
#include "../IGraphicsDevice.h"
#include "Foundation/Logging/Logger.h"
#include "Foundation/StringView.h"
#include "Foundation/Platform/WindowData.h"
 
#ifndef __EMSCRIPTEN__
#include <dlfcn.h>
 
PFNEGLGETPROCADDRESSPROC _eglGetProcAddress = nullptr;
#endif
 
namespace {
 
  Cogs::Logging::Log logger = Cogs::Logging::getLogger("EGLContext");
 
static bool initialized = false;
 
#ifdef __EMSCRIPTEN__
 
#define _eglBindAPI             eglBindAPI
#define _eglChooseConfig        eglChooseConfig
#define _eglCreateContext       eglCreateContext
#define _eglCreateWindowSurface eglCreateWindowSurface
#define _eglDestroyContext      eglDestroyContext
#define _eglDestroySurface      eglDestroySurface
#define _eglGetConfigAttrib     eglGetConfigAttrib
#define _eglGetDisplay          eglGetDisplay
#define _eglGetError            eglGetError
#define _eglGetPlatformDisplay  eglGetPlatformDisplay
#define _eglGetProcAddress      eglGetProcAddress
#define _eglInitialize          eglInitialize
#define _eglMakeCurrent         eglMakeCurrent
#define _eglQueryString         eglQueryString 
#define _eglSwapBuffers         eglSwapBuffers
#define _eglTerminate           eglTerminate
 
  bool initialize() { return true; }
 
#else
 
  PFNEGLBINDAPIPROC                 _eglBindAPI                 = nullptr;
  PFNEGLCHOOSECONFIGPROC            _eglChooseConfig            = nullptr;
  PFNEGLCREATECONTEXTPROC           _eglCreateContext           = nullptr;
  PFNEGLCREATEWINDOWSURFACEPROC     _eglCreateWindowSurface     = nullptr;
  PFNEGLDESTROYCONTEXTPROC          _eglDestroyContext          = nullptr;
  PFNEGLDESTROYSURFACEPROC          _eglDestroySurface          = nullptr;
  PFNEGLGETCONFIGATTRIBPROC         _eglGetConfigAttrib         = nullptr;
  PFNEGLGETDISPLAYPROC              _eglGetDisplay              = nullptr;
  PFNEGLGETPLATFORMDISPLAYPROC      _eglGetPlatformDisplay      = nullptr;
  PFNEGLGETERRORPROC                _eglGetError                = nullptr;
  PFNEGLINITIALIZEPROC              _eglInitialize              = nullptr;
  PFNEGLMAKECURRENTPROC             _eglMakeCurrent             = nullptr;
  PFNEGLQUERYSTRINGPROC             _eglQueryString             = nullptr;
  PFNEGLSWAPBUFFERSPROC             _eglSwapBuffers             = nullptr;
  PFNEGLTERMINATEPROC               _eglTerminate               = nullptr;
 
  PFNEGLGETDISPLAYDRIVERCONFIGPROC  _eglGetDisplayDriverConfig  = nullptr;
  PFNEGLGETDISPLAYDRIVERNAMEPROC    _eglGetDisplayDriverName    = nullptr;
 
  void* libEGL = nullptr;
  static const char* libEGLNames[] = {
    "libEGL.so"
  };
  struct {
    void** ptr;
    const char* name;
  } libEGLFuncs[] = {
    { (void**)&_eglBindAPI, "eglBindAPI" },
    { (void**)&_eglChooseConfig, "eglChooseConfig" },
    { (void**)&_eglCreateContext, "eglCreateContext" },
    { (void**)&_eglCreateWindowSurface, "eglCreateWindowSurface" },
    { (void**)&_eglDestroyContext, "eglDestroyContext" },
    { (void**)&_eglDestroySurface, "eglDestroySurface" },
    { (void**)&_eglGetConfigAttrib, "eglGetConfigAttrib" },
    { (void**)&_eglGetDisplay, "eglGetDisplay" },
    { (void**)&_eglGetError, "eglGetError" },
    { (void**)&_eglGetPlatformDisplay, "eglGetPlatformDisplay" },
    { (void**)&_eglInitialize, "eglInitialize" },
    { (void**)&_eglMakeCurrent, "eglMakeCurrent" },
    { (void**)&_eglQueryString, "eglQueryString" },
    { (void**)&_eglSwapBuffers, "eglSwapBuffers" },
    { (void**)&_eglTerminate, "eglTerminate" },
  };
 
  bool initialize()
  {
    // Open libEGL
    for (const char* libEGLName : libEGLNames) {
      libEGL = dlopen(libEGLName, RTLD_LAZY | RTLD_LOCAL);
      if (libEGL) { goto egl_loaded; }
    }
    LOG_FATAL(logger, "Failed to load libEGL");
    return false;
 
  egl_loaded:
 
    _eglGetProcAddress = (PFNEGLGETPROCADDRESSPROC)dlsym(libEGL, "eglGetProcAddress");
    if(_eglGetProcAddress == nullptr) {
      LOG_FATAL(logger, "Failed to lookup libEGL function eglGetProcAddress");
      //return false;
    }
 
    for (const auto& libFunc : libEGLFuncs) {
      *libFunc.ptr = (void*)_eglGetProcAddress(libFunc.name);
      if(*libFunc.ptr == nullptr) {
        LOG_FATAL(logger, "Failed to look up libEGL function %s", libFunc.name);
        return false;
      }
    }
    return true;
  }
 
#endif
 
 
  const char* eglErrorString(EGLint error)
  {
    switch (error) {
    case EGL_SUCCESS:             return "EGL_SUCCESS";
    case EGL_NOT_INITIALIZED:     return "EGL_NOT_INITIALIZED";
    case EGL_BAD_ACCESS:          return "EGL_BAD_ACCESS";
    case EGL_BAD_ALLOC:           return "EGL_BAD_ALLOC";
    case EGL_BAD_ATTRIBUTE:       return "EGL_BAD_ATTRIBUTE";
    case EGL_BAD_CONTEXT:         return "EGL_BAD_CONTEXT";
    case EGL_BAD_CONFIG:          return "EGL_BAD_CONFIG";
    case EGL_BAD_CURRENT_SURFACE: return "EGL_BAD_CURRENT_SURFACE";
    case EGL_BAD_DISPLAY:         return "EGL_BAD_DISPLAY";
    case EGL_BAD_SURFACE:         return "EGL_BAD_SURFACE";
    case EGL_BAD_MATCH:           return "EGL_BAD_MATCH";
    case EGL_BAD_PARAMETER:       return "EGL_BAD_PARAMETER";
    case EGL_BAD_NATIVE_PIXMAP:   return "EGL_BAD_NATIVE_PIXMAP";
    case EGL_BAD_NATIVE_WINDOW:   return "EGL_BAD_NATIVE_WINDOW";
    case EGL_CONTEXT_LOST:        return "EGL_CONTEXT_LOST";
    default:
      return "<unknown>";
    }
  }
  
 
 
  EGLConfig chooseConfig(EGLDisplay eglDisplay, EGLint surfaceType, EGLint requestedSampleCount)
  {
    EGLint attribList[] =
    {
      EGL_DEPTH_SIZE, 24,
      EGL_SURFACE_TYPE, surfaceType,
      //EGL_SAMPLE_BUFFERS, 1,
      //EGL_SAMPLES,        4,
      EGL_NONE
    };
    EGLint numConfigs = 0;
    if (!_eglChooseConfig(eglDisplay, attribList, nullptr, 0, &numConfigs)) {
      LOG_ERROR(logger, "Failed to choose EGL config: %s", eglErrorString(_eglGetError()));
      return nullptr;
    }
    if(numConfigs == 0) {
      LOG_FATAL(logger, "eglChooseConfig return 0 matching configs");
      return nullptr;    
    }
    std::vector<EGLConfig> configs(numConfigs);
    if (!_eglChooseConfig(eglDisplay, attribList, configs.data(), numConfigs, &numConfigs)) {
      LOG_FATAL(logger, "Failed to choose EGL config: %s", eglErrorString(_eglGetError()));
      return nullptr;
    }
 
    EGLint bestFbc = -1;
    EGLint bestSampleCount = -1;
    LOG_DEBUG(logger, "eglChooseConfig returned %d configs:", numConfigs);
    for(EGLint i=0; i<numConfigs; i++) {
      struct {
        GLint a;
        GLint v = 0;
      } a[] = {
        { EGL_NATIVE_VISUAL_ID },
        { EGL_RED_SIZE },
        { EGL_GREEN_SIZE },
        { EGL_BLUE_SIZE },
        { EGL_ALPHA_SIZE },
        { EGL_DEPTH_SIZE },
        { EGL_SURFACE_TYPE },
        { EGL_SAMPLE_BUFFERS },
        { EGL_SAMPLES },
      };
      for(auto& attrib : a) {
        if(!_eglGetConfigAttrib(eglDisplay, configs[i], attrib.a, &attrib.v)) {
          LOG_ERROR(logger, "eglGetConfigAttrib failed for attribute 0x%x: %s", attrib.a, eglErrorString(_eglGetError()));
        }
      }
 
      EGLint sampleBuffers = a[7].v;
      EGLint sampleCount = a[8].v;
      if ((bestFbc < 0) || (sampleBuffers && (bestSampleCount < sampleCount) && (sampleCount <= requestedSampleCount))) {
        bestFbc = i;
        bestSampleCount = sampleCount;
      }
      LOG_DEBUG(logger, "%i: conf=0x%zx vid=0x%x, rgba={%d %d %d %d} d=%d surfype=0x%x sampleBufs=%d samples=%d",
                i, (size_t)configs[i], a[0].v,
                a[1].v, a[2].v, a[2].v, a[4].v, a[5].v,
                a[6].v, sampleBuffers, sampleCount);
    }
    LOG_DEBUG(logger, "Requested %d samples, chose config %d", requestedSampleCount, bestFbc);
 
    // Just choose the first for now
    return configs[0];    
  }
 
  static bool has_EGL_KHR_no_config_context = false; // https://registry.khronos.org/EGL/extensions/KHR/EGL_KHR_no_config_context.txt
  static bool has_EGL_MESA_query_driver = false;     // https://registry.khronos.org/EGL/extensions/MESA/EGL_MESA_query_driver.txt
 
  void queryDisplayExtensions(EGLDisplay eglDisplay)
  {
    if(const char* eglExtensions = _eglQueryString(eglDisplay, EGL_EXTENSIONS); eglExtensions) {
      for(const char* a=eglExtensions; a && *a!='\0'; ) {
        const char* b = a;
        while(*b != ' ' && *b != '\0')  b++;
        Cogs::StringView extension(a, b-a);
        LOG_DEBUG(logger, "EGL extension %.*s", StringViewFormat(extension));
        switch(Cogs::hash(extension)) {
        case Cogs::hash("EGL_KHR_no_config_context"):
          has_EGL_KHR_no_config_context = true;
          break;
#ifndef __EMSCRIPTEN__
        case Cogs::hash("EGL_MESA_query_driver"):
          _eglGetDisplayDriverName = (PFNEGLGETDISPLAYDRIVERNAMEPROC)_eglGetProcAddress("eglGetDisplayDriverName");
          _eglGetDisplayDriverConfig = (PFNEGLGETDISPLAYDRIVERCONFIGPROC)_eglGetProcAddress("eglGetDisplayDriverConfig");
          has_EGL_MESA_query_driver = true;
          break;
#endif
        }
        while(*b == ' ' && *b != '\0')  b++;
        a = b;
      }
    }
    else {
      LOG_DEBUG(logger, "No EGL extensions");
    }
    if(has_EGL_MESA_query_driver) {
#ifndef __EMSCRIPTEN__
      LOG_DEBUG(logger, "EGL display driver: %s", _eglGetDisplayDriverName(eglDisplay));
      //LOG_DEBUG(logger, "EGL display config: %s", _eglGetDisplayDriverConfig(eglDisplay));
#endif
    }
 
  }
 
}
 
 
bool Cogs::GLContext::create(NativeDisplay display, WindowData* windowData, GLContext* shareContext, const GraphicsDeviceSettings* settings, Platform desiredPlatform, bool debug)
{
  assert(eglDisplay == nullptr);
  assert(eglContext == nullptr);
  assert(eglSurface == nullptr);
  if (!initialized) {
    if (!initialize()) return false;
  }
 
  // ------- Set up display connection ---------------------------------------
  if(shareContext && shareContext->eglDisplay != EGL_NO_DISPLAY) {
    eglDisplay = shareContext->eglDisplay;
  }
 
  else {
 
    if(display) {
#ifdef __linux__
        // Requires EGL 1.5
        eglDisplay = _eglGetPlatformDisplay(EGL_PLATFORM_X11_EXT, display, NULL);
#else
        eglDisplay = _eglGetDisplay(display);
#endif
    }
    else {
  #if 0
      PFNEGLQUERYDEVICESEXTPROC       eglQueryDevicesEXT = reinterpret_cast<PFNEGLQUERYDEVICESEXTPROC>(_eglGetProcAddress("eglQueryDevicesEXT"));
      PFNEGLGETPLATFORMDISPLAYEXTPROC eglGetPlatformDisplayEXT = reinterpret_cast<PFNEGLGETPLATFORMDISPLAYEXTPROC>(_eglGetProcAddress("eglGetPlatformDisplayEXT"));
 
      if(eglQueryDevicesEXT && eglGetPlatformDisplayEXT){
        constexpr int maxDevices = 4;
        EGLDeviceEXT  eglDevs[maxDevices];
        EGLint        numDevices;
 
        _eglQueryDevicesEXT(maxDevices, eglDevs, &numDevices);
        eglDisplay = _eglGetPlatformDisplayEXT(EGL_PLATFORM_DEVICE_EXT, eglDevs[0], 0);
      }
      else{
        eglDisplay = _eglGetDisplay(EGL_DEFAULT_DISPLAY);
      }
  #endif
      eglDisplay = _eglGetDisplay(EGL_DEFAULT_DISPLAY);
    }
 
    if (eglDisplay == EGL_NO_DISPLAY) {
      LOG_FATAL(logger, "Failed to aquire EGL display: %s", eglErrorString(_eglGetError()));
      return false;
    }
    ownDisplay = true;
 
    // ------- Initialize EGL and bind to either GL or GLES --------------------
    EGLint major = 0;
    EGLint minor = 0;
    if (!_eglInitialize(eglDisplay, &major, &minor)) {
      LOG_FATAL(logger, "Failed to initialize EGL: %s", eglErrorString(_eglGetError()));
      return false;
    }
    LOG_DEBUG(logger, "EGL %d.%d initialized", major, minor);
    LOG_DEBUG(logger, "EGL vendor: %s", _eglQueryString(eglDisplay, EGL_VENDOR));
    LOG_DEBUG(logger, "EGL version: %s", _eglQueryString(eglDisplay, EGL_VERSION));
    LOG_DEBUG(logger, "EGL client APIs: %s", _eglQueryString(eglDisplay, EGL_CLIENT_APIS));
    // Version specified implies ES
    if(desiredPlatform == Platform::ES3) {
      if((major == 1) && (minor < 2)) {
        LOG_FATAL(logger, "Insufficient EGL version, minimum supported is 1.2");
        return false;
      }
      if (!_eglBindAPI(EGL_OPENGL_ES_API)) {
        LOG_FATAL(logger, "Failed to bind OPENGL ES API");
        return false;
      }
    }
    else {
      if((major == 1) && (minor < 4)) {
        LOG_FATAL(logger, "Insufficient EGL version for OpenGL usage, minimum supported is 1.4");
        return false;
      }
      if (!_eglBindAPI(EGL_OPENGL_API)) {
        LOG_FATAL(logger, "Failed to bind OPENGL API");
        return false;
      }
    }
  }
 
 
  if(!initialized) {
    queryDisplayExtensions(eglDisplay);
  }
 
  EGLConfig config = nullptr;
 
  // ------- Create surface if needed ----------------------------------------
  if(windowData && windowData->windowHandle) {
 
    if(!config) {
      config = chooseConfig(eglDisplay, EGL_WINDOW_BIT, settings ? settings->numSamples : 0);
      if(!config) return false;
    }
 
    eglSurface = _eglCreateWindowSurface(eglDisplay, config, windowData->windowHandle, nullptr);
    if (eglSurface == EGL_NO_SURFACE) {
      LOG_FATAL(logger, "Failed to create EGL window surface: %s", eglErrorString(_eglGetError()));
      return false;
    }
  }
 
  else {
#if 0
    // Not necessary for dummy contexts
    static constexpr EGLint attributes[] = {
      EGL_WIDTH, 32,
      EGL_HEIGHT, 32,
      //EGL_TEXTURE_FORMAT, EGL_TEXTURE_RGB,
      //EGL_TEXTURE_TARGET, EGL_TEXTURE_2D,
      EGL_NONE
    };
    eglSurface = _eglCreatePbufferSurface(eglDisplay, config, attributes);
    if (eglSurface == EGL_NO_SURFACE) {
      LOG_FATAL(logger, "Failed to create EGL pbuffer surface: %s", eglErrorString(_eglGetError()));
      return false;
    }
#endif
  }
 
  // ------- Create context --------------------------------------------------
  if(has_EGL_KHR_no_config_context && shareContext && shareContext->eglContext) {
    eglContext = shareContext->eglContext;
  }
  else {
    std::vector<EGLint> contextAttributes;
    switch (desiredPlatform) {
    case Platform::ES3:
      contextAttributes.push_back(EGL_CONTEXT_MAJOR_VERSION);
      contextAttributes.push_back(3);
      break;
 
    case Platform::GL:
      contextAttributes.push_back(EGL_CONTEXT_MAJOR_VERSION);
      contextAttributes.push_back(4);
      contextAttributes.push_back(EGL_CONTEXT_MINOR_VERSION);
      contextAttributes.push_back(3);
      //contextAttributes.push_back(EGL_CONTEXT_OPENGL_PROFILE_MASK);
      //contextAttributes.push_back(EGL_CONTEXT_OPENGL_COMPATIBILITY_PROFILE_BIT);
      break;
 
    default:
      assert(false);
      return false;
    }
 
  #ifndef __EMSCRIPTEN__
    if (debug) {
      contextAttributes.push_back(EGL_CONTEXT_FLAGS_KHR);
      contextAttributes.push_back(EGL_CONTEXT_OPENGL_DEBUG_BIT_KHR);
    }
  #endif // of not __EMSCRIPTEN__
    contextAttributes.push_back(EGL_NONE);
    contextAttributes.push_back(EGL_NONE);
 
    if(!config && !has_EGL_KHR_no_config_context) {
      config = chooseConfig(eglDisplay, 0, settings ? settings->numSamples : 0); // EGL_PBUFFER_BIT ?
      if(!config) return false;
    }
 
    eglContext = _eglCreateContext(eglDisplay,
                                  has_EGL_KHR_no_config_context ? nullptr : config,
                                  shareContext ? shareContext->eglContext : EGL_CAST(::EGLContext, 0),
                                  contextAttributes.data());
    if (!eglContext) {
      LOG_ERROR(logger, "Failed to create EGL context: %s", eglErrorString(_eglGetError()));
      return false;
    }
    LOG_DEBUG(logger, "Created EGL context");
    ownContext = true;
  }
 
  makeCurrent();
#ifndef __EMSCRIPTEN__
  if (!initialized) {
    getGLFuncPointers();
  }
  if (debug) {
    Cogs::setUpGLDebugging(nullptr, platform);
  }
#else
  (void)debug;
#endif // of else not __EMSCRIPTEN__
 
  glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
  
  initialized = true;
  return true;
}
 
bool Cogs::GLContext::makeCurrent()
{
  if (!_eglMakeCurrent(eglDisplay, eglSurface, eglSurface, eglContext)) {
    LOG_ERROR_ONCE(logger, "Failed to make EGL context current: %s", eglErrorString(_eglGetError()));
    return false;
  }
 
  return true;
}
 
void Cogs::GLContext::swapBuffers(uint32_t /*syncInterval*/, uint32_t /*presentFlags*/)
{
#ifndef __EMSCRIPTEN__
  //_eglSwapInterval(this->eglDisplay, 1);
  if(!_eglSwapBuffers(eglDisplay, eglSurface)) {
    LOG_ERROR_ONCE(logger, "Failed to swap EGL buffers: %s", eglErrorString(_eglGetError()));
 }
#else 
  glFlush();
#endif
}
 
void Cogs::GLContext::destroy()
{
  if(eglDisplay) {
    if(eglSurface) {
      _eglDestroySurface(eglDisplay, eglSurface);
      eglSurface = nullptr;
    }
    if(eglContext) {
      if(ownContext) {
        _eglDestroyContext(eglDisplay, eglContext);
      }
      eglContext = nullptr;
    }
    if(ownDisplay) {
      _eglTerminate(eglDisplay);
    }
    eglDisplay = nullptr;
  }
}
 
#endif // of COGS_EGL