/* * Simple DirectMedia Layer * Copyright (C) 1997-2023 Sam Lantinga * * This software is provided 'as-is', without any express or implied * warranty. In no event will the authors be held liable for any damages * arising from the use of this software. * * Permission is granted to anyone to use this software for any purpose, * including commercial applications, and to alter it and redistribute it * freely, subject to the following restrictions: * * 1. The origin of this software must not be misrepresented; you must not * claim that you wrote the original software. If you use this software * in a product, an acknowledgment in the product documentation would be * appreciated but is not required. * 2. Altered source versions must be plainly marked as such, and must not be * misrepresented as being the original software. * 3. This notice may not be removed or altered from any source distribution. */ #include "SDL_internal.h" #ifdef SDL_VIDEO_OPENGL_EGL #if defined(SDL_VIDEO_DRIVER_WINDOWS) || defined(SDL_VIDEO_DRIVER_WINRT) #include "../core/windows/SDL_windows.h" #endif #ifdef SDL_VIDEO_DRIVER_ANDROID #include #include "../video/android/SDL_androidvideo.h" #endif #ifdef SDL_VIDEO_DRIVER_RPI #include #endif #ifdef SDL_VIDEO_VITA_PVR_OGL #include #endif #include "SDL_sysvideo.h" #include "SDL_egl_c.h" #ifdef EGL_KHR_create_context /* EGL_OPENGL_ES3_BIT_KHR was added in version 13 of the extension. */ #ifndef EGL_OPENGL_ES3_BIT_KHR #define EGL_OPENGL_ES3_BIT_KHR 0x00000040 #endif #endif /* EGL_KHR_create_context */ #ifndef EGL_EXT_pixel_format_float #define EGL_EXT_pixel_format_float #define EGL_COLOR_COMPONENT_TYPE_EXT 0x3339 #define EGL_COLOR_COMPONENT_TYPE_FIXED_EXT 0x333A #define EGL_COLOR_COMPONENT_TYPE_FLOAT_EXT 0x333B #endif #ifndef EGL_EXT_present_opaque #define EGL_EXT_present_opaque 1 #define EGL_PRESENT_OPAQUE_EXT 0x31DF #endif /* EGL_EXT_present_opaque */ #ifdef SDL_VIDEO_DRIVER_RPI /* Raspbian places the OpenGL ES/EGL binaries in a non standard path */ #define DEFAULT_EGL (vc4 ? "libEGL.so.1" : "libbrcmEGL.so") #define DEFAULT_OGL_ES2 (vc4 ? "libGLESv2.so.2" : "libbrcmGLESv2.so") #define ALT_EGL "libEGL.so" #define ALT_OGL_ES2 "libGLESv2.so" #define DEFAULT_OGL_ES_PVR (vc4 ? "libGLES_CM.so.1" : "libbrcmGLESv2.so") #define DEFAULT_OGL_ES (vc4 ? "libGLESv1_CM.so.1" : "libbrcmGLESv2.so") #elif defined(SDL_VIDEO_DRIVER_ANDROID) || defined(SDL_VIDEO_DRIVER_VIVANTE) /* Android */ #define DEFAULT_EGL "libEGL.so" #define DEFAULT_OGL_ES2 "libGLESv2.so" #define DEFAULT_OGL_ES_PVR "libGLES_CM.so" #define DEFAULT_OGL_ES "libGLESv1_CM.so" #elif defined(SDL_VIDEO_DRIVER_WINDOWS) || defined(SDL_VIDEO_DRIVER_WINRT) /* EGL AND OpenGL ES support via ANGLE */ #define DEFAULT_EGL "libEGL.dll" #define DEFAULT_OGL "opengl32.dll" #define DEFAULT_OGL_ES2 "libGLESv2.dll" #define DEFAULT_OGL_ES_PVR "libGLES_CM.dll" #define DEFAULT_OGL_ES "libGLESv1_CM.dll" #elif defined(SDL_VIDEO_DRIVER_COCOA) /* EGL AND OpenGL ES support via ANGLE */ #define DEFAULT_EGL "libEGL.dylib" #define DEFAULT_OGL_ES2 "libGLESv2.dylib" #define DEFAULT_OGL_ES_PVR "libGLES_CM.dylib" //??? #define DEFAULT_OGL_ES "libGLESv1_CM.dylib" //??? #elif defined(__OpenBSD__) /* OpenBSD */ #define DEFAULT_OGL "libGL.so" #define DEFAULT_EGL "libEGL.so" #define DEFAULT_OGL_ES2 "libGLESv2.so" #define DEFAULT_OGL_ES_PVR "libGLES_CM.so" #define DEFAULT_OGL_ES "libGLESv1_CM.so" #else /* Desktop Linux/Unix-like */ #define DEFAULT_OGL "libGL.so.1" #define DEFAULT_EGL "libEGL.so.1" #define ALT_OGL "libOpenGL.so.0" #define DEFAULT_OGL_ES2 "libGLESv2.so.2" #define DEFAULT_OGL_ES_PVR "libGLES_CM.so.1" #define DEFAULT_OGL_ES "libGLESv1_CM.so.1" #endif /* SDL_VIDEO_DRIVER_RPI */ #if defined(SDL_VIDEO_OPENGL) && !defined(SDL_VIDEO_VITA_PVR_OGL) #include #endif /** If we happen to not have this defined because of an older EGL version, just define it 0x0 as eglGetPlatformDisplayEXT will most likely be NULL if this is missing */ #ifndef EGL_PLATFORM_DEVICE_EXT #define EGL_PLATFORM_DEVICE_EXT 0x0 #endif #ifdef SDL_VIDEO_OPENGL typedef void (APIENTRY* PFNGLGETINTEGERVPROC) (GLenum pname, GLint * params); #endif #if defined(SDL_VIDEO_STATIC_ANGLE) || defined(SDL_VIDEO_DRIVER_VITA) #define LOAD_FUNC(TYPE, NAME) \ _this->egl_data->NAME = NAME; #else #define LOAD_FUNC(TYPE, NAME) \ _this->egl_data->NAME = (TYPE)SDL_LoadFunction(_this->egl_data->egl_dll_handle, #NAME); \ if (!_this->egl_data->NAME) { \ return SDL_SetError("Could not retrieve EGL function " #NAME); \ } #endif /* it is allowed to not have some of the EGL extensions on start - attempts to use them will fail later. */ #define LOAD_FUNC_EGLEXT(TYPE, NAME) \ _this->egl_data->NAME = (TYPE)_this->egl_data->eglGetProcAddress(#NAME); static const char *SDL_EGL_GetErrorName(EGLint eglErrorCode) { #define SDL_EGL_ERROR_TRANSLATE(e) \ case e: \ return #e; switch (eglErrorCode) { SDL_EGL_ERROR_TRANSLATE(EGL_SUCCESS); SDL_EGL_ERROR_TRANSLATE(EGL_NOT_INITIALIZED); SDL_EGL_ERROR_TRANSLATE(EGL_BAD_ACCESS); SDL_EGL_ERROR_TRANSLATE(EGL_BAD_ALLOC); SDL_EGL_ERROR_TRANSLATE(EGL_BAD_ATTRIBUTE); SDL_EGL_ERROR_TRANSLATE(EGL_BAD_CONTEXT); SDL_EGL_ERROR_TRANSLATE(EGL_BAD_CONFIG); SDL_EGL_ERROR_TRANSLATE(EGL_BAD_CURRENT_SURFACE); SDL_EGL_ERROR_TRANSLATE(EGL_BAD_DISPLAY); SDL_EGL_ERROR_TRANSLATE(EGL_BAD_SURFACE); SDL_EGL_ERROR_TRANSLATE(EGL_BAD_MATCH); SDL_EGL_ERROR_TRANSLATE(EGL_BAD_PARAMETER); SDL_EGL_ERROR_TRANSLATE(EGL_BAD_NATIVE_PIXMAP); SDL_EGL_ERROR_TRANSLATE(EGL_BAD_NATIVE_WINDOW); SDL_EGL_ERROR_TRANSLATE(EGL_CONTEXT_LOST); } return ""; } int SDL_EGL_SetErrorEx(const char *message, const char *eglFunctionName, EGLint eglErrorCode) { const char *errorText = SDL_EGL_GetErrorName(eglErrorCode); char altErrorText[32]; if (errorText[0] == '\0') { /* An unknown-to-SDL error code was reported. Report its hexadecimal value, instead of its name. */ (void)SDL_snprintf(altErrorText, SDL_arraysize(altErrorText), "0x%x", (unsigned int)eglErrorCode); errorText = altErrorText; } return SDL_SetError("%s (call to %s failed, reporting an error of %s)", message, eglFunctionName, errorText); } /* EGL implementation of SDL OpenGL ES support */ SDL_bool SDL_EGL_HasExtension(SDL_VideoDevice *_this, SDL_EGL_ExtensionType type, const char *ext) { size_t ext_len; const char *ext_override; const char *egl_extstr; const char *ext_start; /* Invalid extensions can be rejected early */ if (ext == NULL || *ext == 0 || SDL_strchr(ext, ' ') != NULL) { /* SDL_LogDebug(SDL_LOG_CATEGORY_VIDEO, "SDL_EGL_HasExtension: Invalid EGL extension"); */ return SDL_FALSE; } /* Extensions can be masked with an environment variable. * Unlike the OpenGL override, this will use the set bits of an integer * to disable the extension. * Bit Action * 0 If set, the display extension is masked and not present to SDL. * 1 If set, the client extension is masked and not present to SDL. */ ext_override = SDL_getenv(ext); if (ext_override != NULL) { int disable_ext = SDL_atoi(ext_override); if (disable_ext & 0x01 && type == SDL_EGL_DISPLAY_EXTENSION) { return SDL_FALSE; } else if (disable_ext & 0x02 && type == SDL_EGL_CLIENT_EXTENSION) { return SDL_FALSE; } } ext_len = SDL_strlen(ext); switch (type) { case SDL_EGL_DISPLAY_EXTENSION: egl_extstr = _this->egl_data->eglQueryString(_this->egl_data->egl_display, EGL_EXTENSIONS); break; case SDL_EGL_CLIENT_EXTENSION: /* EGL_EXT_client_extensions modifies eglQueryString to return client extensions * if EGL_NO_DISPLAY is passed. Implementations without it are required to return NULL. * This behavior is included in EGL 1.5. */ egl_extstr = _this->egl_data->eglQueryString(EGL_NO_DISPLAY, EGL_EXTENSIONS); break; default: /* SDL_LogDebug(SDL_LOG_CATEGORY_VIDEO, "SDL_EGL_HasExtension: Invalid extension type"); */ return SDL_FALSE; } if (egl_extstr != NULL) { ext_start = egl_extstr; while (*ext_start) { ext_start = SDL_strstr(ext_start, ext); if (ext_start == NULL) { return SDL_FALSE; } /* Check if the match is not just a substring of one of the extensions */ if (ext_start == egl_extstr || *(ext_start - 1) == ' ') { if (ext_start[ext_len] == ' ' || ext_start[ext_len] == 0) { return SDL_TRUE; } } /* If the search stopped in the middle of an extension, skip to the end of it */ ext_start += ext_len; while (*ext_start != ' ' && *ext_start != 0) { ext_start++; } } } return SDL_FALSE; } SDL_FunctionPointer SDL_EGL_GetProcAddressInternal(SDL_VideoDevice *_this, const char *proc) { SDL_FunctionPointer retval = NULL; if (_this->egl_data != NULL) { const Uint32 eglver = (((Uint32)_this->egl_data->egl_version_major) << 16) | ((Uint32)_this->egl_data->egl_version_minor); const SDL_bool is_egl_15_or_later = eglver >= ((((Uint32)1) << 16) | 5); /* EGL 1.5 can use eglGetProcAddress() for any symbol. 1.4 and earlier can't use it for core entry points. */ if (retval == NULL && is_egl_15_or_later && _this->egl_data->eglGetProcAddress) { retval = _this->egl_data->eglGetProcAddress(proc); } #if !defined(__EMSCRIPTEN__) && !defined(SDL_VIDEO_DRIVER_VITA) /* LoadFunction isn't needed on Emscripten and will call dlsym(), causing other problems. */ /* Try SDL_LoadFunction() first for EGL <= 1.4, or as a fallback for >= 1.5. */ if (retval == NULL) { retval = SDL_LoadFunction(_this->egl_data->opengl_dll_handle, proc); } #endif /* Try eglGetProcAddress if we're on <= 1.4 and still searching... */ if (retval == NULL && !is_egl_15_or_later && _this->egl_data->eglGetProcAddress) { retval = _this->egl_data->eglGetProcAddress(proc); } } return retval; } void SDL_EGL_UnloadLibrary(SDL_VideoDevice *_this) { if (_this->egl_data) { if (_this->egl_data->egl_display) { _this->egl_data->eglTerminate(_this->egl_data->egl_display); _this->egl_data->egl_display = NULL; } if (_this->egl_data->egl_dll_handle) { SDL_UnloadObject(_this->egl_data->egl_dll_handle); _this->egl_data->egl_dll_handle = NULL; } if (_this->egl_data->opengl_dll_handle) { SDL_UnloadObject(_this->egl_data->opengl_dll_handle); _this->egl_data->opengl_dll_handle = NULL; } SDL_free(_this->egl_data); _this->egl_data = NULL; } } static int SDL_EGL_LoadLibraryInternal(SDL_VideoDevice *_this, const char *egl_path) { void *egl_dll_handle = NULL, *opengl_dll_handle = NULL; const char *path = NULL; #if defined(SDL_VIDEO_DRIVER_WINDOWS) || defined(SDL_VIDEO_DRIVER_WINRT) const char *d3dcompiler; #endif #ifdef SDL_VIDEO_DRIVER_RPI SDL_bool vc4 = (0 == access("/sys/module/vc4/", F_OK)); #endif #if defined(SDL_VIDEO_DRIVER_WINDOWS) || defined(SDL_VIDEO_DRIVER_WINRT) d3dcompiler = SDL_GetHint(SDL_HINT_VIDEO_WIN_D3DCOMPILER); if (d3dcompiler) { if (SDL_strcasecmp(d3dcompiler, "none") != 0) { if (SDL_LoadObject(d3dcompiler) == NULL) { SDL_ClearError(); } } } else { if (WIN_IsWindowsVistaOrGreater()) { /* Try the newer d3d compilers first */ const char *d3dcompiler_list[] = { "d3dcompiler_47.dll", "d3dcompiler_46.dll", }; int i; for (i = 0; i < SDL_arraysize(d3dcompiler_list); ++i) { if (SDL_LoadObject(d3dcompiler_list[i]) != NULL) { break; } SDL_ClearError(); } } else { if (SDL_LoadObject("d3dcompiler_43.dll") == NULL) { SDL_ClearError(); } } } #endif #if !defined(SDL_VIDEO_STATIC_ANGLE) && !defined(SDL_VIDEO_DRIVER_VITA) /* A funny thing, loading EGL.so first does not work on the Raspberry, so we load libGL* first */ path = SDL_getenv("SDL_VIDEO_GL_DRIVER"); if (path != NULL) { opengl_dll_handle = SDL_LoadObject(path); } if (opengl_dll_handle == NULL) { if (_this->gl_config.profile_mask == SDL_GL_CONTEXT_PROFILE_ES) { if (_this->gl_config.major_version > 1) { path = DEFAULT_OGL_ES2; opengl_dll_handle = SDL_LoadObject(path); #ifdef ALT_OGL_ES2 if (opengl_dll_handle == NULL && !vc4) { path = ALT_OGL_ES2; opengl_dll_handle = SDL_LoadObject(path); } #endif } else { path = DEFAULT_OGL_ES; opengl_dll_handle = SDL_LoadObject(path); if (opengl_dll_handle == NULL) { path = DEFAULT_OGL_ES_PVR; opengl_dll_handle = SDL_LoadObject(path); } #ifdef ALT_OGL_ES2 if (opengl_dll_handle == NULL && !vc4) { path = ALT_OGL_ES2; opengl_dll_handle = SDL_LoadObject(path); } #endif } } #ifdef DEFAULT_OGL else { path = DEFAULT_OGL; opengl_dll_handle = SDL_LoadObject(path); #ifdef ALT_OGL if (opengl_dll_handle == NULL) { path = ALT_OGL; opengl_dll_handle = SDL_LoadObject(path); } #endif } #endif } _this->egl_data->opengl_dll_handle = opengl_dll_handle; if (opengl_dll_handle == NULL) { return SDL_SetError("Could not initialize OpenGL / GLES library"); } /* Loading libGL* in the previous step took care of loading libEGL.so, but we future proof by double checking */ if (egl_path != NULL) { egl_dll_handle = SDL_LoadObject(egl_path); } /* Try loading a EGL symbol, if it does not work try the default library paths */ if (egl_dll_handle == NULL || SDL_LoadFunction(egl_dll_handle, "eglChooseConfig") == NULL) { if (egl_dll_handle != NULL) { SDL_UnloadObject(egl_dll_handle); } path = SDL_getenv("SDL_VIDEO_EGL_DRIVER"); if (path == NULL) { path = DEFAULT_EGL; } egl_dll_handle = SDL_LoadObject(path); #ifdef ALT_EGL if (egl_dll_handle == NULL && !vc4) { path = ALT_EGL; egl_dll_handle = SDL_LoadObject(path); } #endif if (egl_dll_handle == NULL || SDL_LoadFunction(egl_dll_handle, "eglChooseConfig") == NULL) { if (egl_dll_handle != NULL) { SDL_UnloadObject(egl_dll_handle); } return SDL_SetError("Could not load EGL library"); } SDL_ClearError(); } #endif _this->egl_data->egl_dll_handle = egl_dll_handle; #ifdef SDL_VIDEO_DRIVER_VITA _this->egl_data->opengl_dll_handle = opengl_dll_handle; #endif /* Load new function pointers */ LOAD_FUNC(PFNEGLGETDISPLAYPROC, eglGetDisplay); LOAD_FUNC(PFNEGLINITIALIZEPROC, eglInitialize); LOAD_FUNC(PFNEGLTERMINATEPROC, eglTerminate); LOAD_FUNC(PFNEGLGETPROCADDRESSPROC, eglGetProcAddress); LOAD_FUNC(PFNEGLCHOOSECONFIGPROC, eglChooseConfig); LOAD_FUNC(PFNEGLCREATECONTEXTPROC, eglCreateContext); LOAD_FUNC(PFNEGLDESTROYCONTEXTPROC, eglDestroyContext); LOAD_FUNC(PFNEGLCREATEPBUFFERSURFACEPROC, eglCreatePbufferSurface); LOAD_FUNC(PFNEGLCREATEWINDOWSURFACEPROC, eglCreateWindowSurface); LOAD_FUNC(PFNEGLDESTROYSURFACEPROC, eglDestroySurface); LOAD_FUNC(PFNEGLMAKECURRENTPROC, eglMakeCurrent); LOAD_FUNC(PFNEGLSWAPBUFFERSPROC, eglSwapBuffers); LOAD_FUNC(PFNEGLSWAPINTERVALPROC, eglSwapInterval); LOAD_FUNC(PFNEGLQUERYSTRINGPROC, eglQueryString); LOAD_FUNC(PFNEGLGETCONFIGATTRIBPROC, eglGetConfigAttrib); LOAD_FUNC(PFNEGLWAITNATIVEPROC, eglWaitNative); LOAD_FUNC(PFNEGLWAITGLPROC, eglWaitGL); LOAD_FUNC(PFNEGLBINDAPIPROC, eglBindAPI); LOAD_FUNC(PFNEGLGETERRORPROC, eglGetError); LOAD_FUNC_EGLEXT(PFNEGLQUERYDEVICESEXTPROC, eglQueryDevicesEXT); LOAD_FUNC_EGLEXT(PFNEGLGETPLATFORMDISPLAYEXTPROC, eglGetPlatformDisplayEXT); /* Atomic functions */ LOAD_FUNC_EGLEXT(PFNEGLCREATESYNCKHRPROC, eglCreateSyncKHR); LOAD_FUNC_EGLEXT(PFNEGLDESTROYSYNCKHRPROC, eglDestroySyncKHR); LOAD_FUNC_EGLEXT(PFNEGLDUPNATIVEFENCEFDANDROIDPROC, eglDupNativeFenceFDANDROID); LOAD_FUNC_EGLEXT(PFNEGLWAITSYNCKHRPROC, eglWaitSyncKHR); LOAD_FUNC_EGLEXT(PFNEGLCLIENTWAITSYNCKHRPROC, eglClientWaitSyncKHR); /* Atomic functions end */ if (path) { SDL_strlcpy(_this->gl_config.driver_path, path, sizeof(_this->gl_config.driver_path) - 1); } else { *_this->gl_config.driver_path = '\0'; } return 0; } int SDL_EGL_LoadLibraryOnly(SDL_VideoDevice *_this, const char *egl_path) { if (_this->egl_data) { return SDL_SetError("EGL context already created"); } _this->egl_data = (struct SDL_EGL_VideoData *)SDL_calloc(1, sizeof(SDL_EGL_VideoData)); if (!_this->egl_data) { return SDL_OutOfMemory(); } if (SDL_EGL_LoadLibraryInternal(_this, egl_path) < 0) { SDL_free(_this->egl_data); _this->egl_data = NULL; return -1; } return 0; } static void SDL_EGL_GetVersion(SDL_VideoDevice *_this) { if (_this->egl_data->eglQueryString) { const char *egl_version = _this->egl_data->eglQueryString(_this->egl_data->egl_display, EGL_VERSION); if (egl_version) { int major = 0, minor = 0; if (SDL_sscanf(egl_version, "%d.%d", &major, &minor) == 2) { _this->egl_data->egl_version_major = major; _this->egl_data->egl_version_minor = minor; } else { SDL_LogWarn(SDL_LOG_CATEGORY_VIDEO, "Could not parse EGL version string: %s", egl_version); } } } } int SDL_EGL_LoadLibrary(SDL_VideoDevice *_this, const char *egl_path, NativeDisplayType native_display, EGLenum platform) { int library_load_retcode = SDL_EGL_LoadLibraryOnly(_this, egl_path); if (library_load_retcode != 0) { return library_load_retcode; } _this->egl_data->egl_display = EGL_NO_DISPLAY; #ifndef __WINRT__ #ifndef SDL_VIDEO_DRIVER_VITA if (platform) { /* EGL 1.5 allows querying for client version with EGL_NO_DISPLAY * -- * Khronos doc: "EGL_BAD_DISPLAY is generated if display is not an EGL display connection, unless display is EGL_NO_DISPLAY and name is EGL_EXTENSIONS." * Therefore SDL_EGL_GetVersion() shouldn't work with uninitialized display. * - it actually doesn't work on Android that has 1.5 egl client * - it works on desktop X11 (using SDL_VIDEO_FORCE_EGL=1) */ SDL_EGL_GetVersion(_this); if (_this->egl_data->egl_version_major == 1 && _this->egl_data->egl_version_minor == 5) { LOAD_FUNC(PFNEGLGETPLATFORMDISPLAYPROC, eglGetPlatformDisplay); } if (_this->egl_data->eglGetPlatformDisplay) { EGLAttrib *attribs = NULL; if (_this->egl_platformattrib_callback) { attribs = _this->egl_platformattrib_callback(); if (!attribs) { _this->gl_config.driver_loaded = 0; *_this->gl_config.driver_path = '\0'; return SDL_SetError("EGL platform attribute callback returned NULL pointer"); } } _this->egl_data->egl_display = _this->egl_data->eglGetPlatformDisplay(platform, (void *)(uintptr_t)native_display, attribs); } else { if (SDL_EGL_HasExtension(_this, SDL_EGL_CLIENT_EXTENSION, "EGL_EXT_platform_base")) { _this->egl_data->eglGetPlatformDisplayEXT = (PFNEGLGETPLATFORMDISPLAYEXTPROC)SDL_EGL_GetProcAddressInternal(_this, "eglGetPlatformDisplayEXT"); if (_this->egl_data->eglGetPlatformDisplayEXT) { _this->egl_data->egl_display = _this->egl_data->eglGetPlatformDisplayEXT(platform, (void *)(uintptr_t)native_display, NULL); } } } } #endif /* Try the implementation-specific eglGetDisplay even if eglGetPlatformDisplay fails */ if ((_this->egl_data->egl_display == EGL_NO_DISPLAY) && (_this->egl_data->eglGetDisplay != NULL) && SDL_GetHintBoolean(SDL_HINT_VIDEO_EGL_ALLOW_GETDISPLAY_FALLBACK, SDL_TRUE)) { _this->egl_data->egl_display = _this->egl_data->eglGetDisplay(native_display); } if (_this->egl_data->egl_display == EGL_NO_DISPLAY) { _this->gl_config.driver_loaded = 0; *_this->gl_config.driver_path = '\0'; return SDL_SetError("Could not get EGL display"); } if (_this->egl_data->eglInitialize(_this->egl_data->egl_display, NULL, NULL) != EGL_TRUE) { _this->gl_config.driver_loaded = 0; *_this->gl_config.driver_path = '\0'; return SDL_SetError("Could not initialize EGL"); } #endif /* Get the EGL version with a valid egl_display, for EGL <= 1.4 */ SDL_EGL_GetVersion(_this); _this->egl_data->is_offscreen = SDL_FALSE; return 0; } /** On multi GPU machines EGL device 0 is not always the first valid GPU. Container environments can restrict access to some GPUs that are still listed in the EGL device list. If the requested device is a restricted GPU and cannot be used (eglInitialize() will fail) then attempt to automatically and silently select the next valid available GPU for EGL to use. */ int SDL_EGL_InitializeOffscreen(SDL_VideoDevice *_this, int device) { void *egl_devices[SDL_EGL_MAX_DEVICES]; EGLint num_egl_devices = 0; const char *egl_device_hint; if (_this->gl_config.driver_loaded <= 0) { return SDL_SetError("SDL_EGL_LoadLibraryOnly() has not been called or has failed."); } /* Check for all extensions that are optional until used and fail if any is missing */ if (_this->egl_data->eglQueryDevicesEXT == NULL) { return SDL_SetError("eglQueryDevicesEXT is missing (EXT_device_enumeration not supported by the drivers?)"); } if (_this->egl_data->eglGetPlatformDisplayEXT == NULL) { return SDL_SetError("eglGetPlatformDisplayEXT is missing (EXT_platform_base not supported by the drivers?)"); } if (_this->egl_data->eglQueryDevicesEXT(SDL_EGL_MAX_DEVICES, egl_devices, &num_egl_devices) != EGL_TRUE) { return SDL_SetError("eglQueryDevicesEXT() failed"); } egl_device_hint = SDL_GetHint("SDL_HINT_EGL_DEVICE"); if (egl_device_hint) { device = SDL_atoi(egl_device_hint); if (device >= num_egl_devices) { return SDL_SetError("Invalid EGL device is requested."); } _this->egl_data->egl_display = _this->egl_data->eglGetPlatformDisplayEXT(EGL_PLATFORM_DEVICE_EXT, egl_devices[device], NULL); if (_this->egl_data->egl_display == EGL_NO_DISPLAY) { return SDL_SetError("eglGetPlatformDisplayEXT() failed."); } if (_this->egl_data->eglInitialize(_this->egl_data->egl_display, NULL, NULL) != EGL_TRUE) { return SDL_SetError("Could not initialize EGL"); } } else { int i; SDL_bool found = SDL_FALSE; EGLDisplay attempted_egl_display; /* If no hint is provided lets look for the first device/display that will allow us to eglInit */ for (i = 0; i < num_egl_devices; i++) { attempted_egl_display = _this->egl_data->eglGetPlatformDisplayEXT(EGL_PLATFORM_DEVICE_EXT, egl_devices[i], NULL); if (attempted_egl_display == EGL_NO_DISPLAY) { continue; } if (_this->egl_data->eglInitialize(attempted_egl_display, NULL, NULL) != EGL_TRUE) { _this->egl_data->eglTerminate(attempted_egl_display); continue; } /* We did not fail, we'll pick this one! */ _this->egl_data->egl_display = attempted_egl_display; found = SDL_TRUE; break; } if (!found) { return SDL_SetError("Could not find a valid EGL device to initialize"); } } /* Get the EGL version with a valid egl_display, for EGL <= 1.4 */ SDL_EGL_GetVersion(_this); _this->egl_data->is_offscreen = SDL_TRUE; return 0; } void SDL_EGL_SetRequiredVisualId(SDL_VideoDevice *_this, int visual_id) { _this->egl_data->egl_required_visual_id = visual_id; } #ifdef DUMP_EGL_CONFIG #define ATTRIBUTE(_attr) \ { \ _attr, #_attr \ } typedef struct { EGLint attribute; char const *name; } Attribute; static Attribute all_attributes[] = { ATTRIBUTE(EGL_BUFFER_SIZE), ATTRIBUTE(EGL_ALPHA_SIZE), ATTRIBUTE(EGL_BLUE_SIZE), ATTRIBUTE(EGL_GREEN_SIZE), ATTRIBUTE(EGL_RED_SIZE), ATTRIBUTE(EGL_DEPTH_SIZE), ATTRIBUTE(EGL_STENCIL_SIZE), ATTRIBUTE(EGL_CONFIG_CAVEAT), ATTRIBUTE(EGL_CONFIG_ID), ATTRIBUTE(EGL_LEVEL), ATTRIBUTE(EGL_MAX_PBUFFER_HEIGHT), ATTRIBUTE(EGL_MAX_PBUFFER_WIDTH), ATTRIBUTE(EGL_MAX_PBUFFER_PIXELS), ATTRIBUTE(EGL_NATIVE_RENDERABLE), ATTRIBUTE(EGL_NATIVE_VISUAL_ID), ATTRIBUTE(EGL_NATIVE_VISUAL_TYPE), ATTRIBUTE(EGL_SAMPLES), ATTRIBUTE(EGL_SAMPLE_BUFFERS), ATTRIBUTE(EGL_SURFACE_TYPE), ATTRIBUTE(EGL_TRANSPARENT_TYPE), ATTRIBUTE(EGL_TRANSPARENT_BLUE_VALUE), ATTRIBUTE(EGL_TRANSPARENT_GREEN_VALUE), ATTRIBUTE(EGL_TRANSPARENT_RED_VALUE), ATTRIBUTE(EGL_BIND_TO_TEXTURE_RGB), ATTRIBUTE(EGL_BIND_TO_TEXTURE_RGBA), ATTRIBUTE(EGL_MIN_SWAP_INTERVAL), ATTRIBUTE(EGL_MAX_SWAP_INTERVAL), ATTRIBUTE(EGL_LUMINANCE_SIZE), ATTRIBUTE(EGL_ALPHA_MASK_SIZE), ATTRIBUTE(EGL_COLOR_BUFFER_TYPE), ATTRIBUTE(EGL_RENDERABLE_TYPE), ATTRIBUTE(EGL_MATCH_NATIVE_PIXMAP), ATTRIBUTE(EGL_CONFORMANT), }; static void dumpconfig(SDL_VideoDevice *_this, EGLConfig config) { int attr; for (attr = 0; attr < sizeof(all_attributes) / sizeof(Attribute); attr++) { EGLint value; _this->egl_data->eglGetConfigAttrib(_this->egl_data->egl_display, config, all_attributes[attr].attribute, &value); SDL_Log("\t%-32s: %10d (0x%08x)\n", all_attributes[attr].name, value, value); } } #endif /* DUMP_EGL_CONFIG */ static int SDL_EGL_PrivateChooseConfig(SDL_VideoDevice *_this, SDL_bool set_config_caveat_none) { /* 64 seems nice. */ EGLint attribs[64]; EGLint found_configs = 0, value; /* 128 seems even nicer here */ EGLConfig configs[128]; SDL_bool has_matching_format = SDL_FALSE; int i, j, best_bitdiff = -1, best_truecolor_bitdiff = -1; int truecolor_config_idx = -1; /* Get a valid EGL configuration */ i = 0; attribs[i++] = EGL_RED_SIZE; attribs[i++] = _this->gl_config.red_size; attribs[i++] = EGL_GREEN_SIZE; attribs[i++] = _this->gl_config.green_size; attribs[i++] = EGL_BLUE_SIZE; attribs[i++] = _this->gl_config.blue_size; if (set_config_caveat_none) { attribs[i++] = EGL_CONFIG_CAVEAT; attribs[i++] = EGL_NONE; } if (_this->gl_config.alpha_size) { attribs[i++] = EGL_ALPHA_SIZE; attribs[i++] = _this->gl_config.alpha_size; } if (_this->gl_config.buffer_size) { attribs[i++] = EGL_BUFFER_SIZE; attribs[i++] = _this->gl_config.buffer_size; } if (_this->gl_config.depth_size) { attribs[i++] = EGL_DEPTH_SIZE; attribs[i++] = _this->gl_config.depth_size; } if (_this->gl_config.stencil_size) { attribs[i++] = EGL_STENCIL_SIZE; attribs[i++] = _this->gl_config.stencil_size; } if (_this->gl_config.multisamplebuffers) { attribs[i++] = EGL_SAMPLE_BUFFERS; attribs[i++] = _this->gl_config.multisamplebuffers; } if (_this->gl_config.multisamplesamples) { attribs[i++] = EGL_SAMPLES; attribs[i++] = _this->gl_config.multisamplesamples; } if (_this->gl_config.floatbuffers) { attribs[i++] = EGL_COLOR_COMPONENT_TYPE_EXT; attribs[i++] = EGL_COLOR_COMPONENT_TYPE_FLOAT_EXT; } if (_this->egl_data->is_offscreen) { attribs[i++] = EGL_SURFACE_TYPE; attribs[i++] = EGL_PBUFFER_BIT; } attribs[i++] = EGL_RENDERABLE_TYPE; if (_this->gl_config.profile_mask == SDL_GL_CONTEXT_PROFILE_ES) { #ifdef EGL_KHR_create_context if (_this->gl_config.major_version >= 3 && SDL_EGL_HasExtension(_this, SDL_EGL_DISPLAY_EXTENSION, "EGL_KHR_create_context")) { attribs[i++] = EGL_OPENGL_ES3_BIT_KHR; } else #endif if (_this->gl_config.major_version >= 2) { attribs[i++] = EGL_OPENGL_ES2_BIT; } else { attribs[i++] = EGL_OPENGL_ES_BIT; } _this->egl_data->eglBindAPI(EGL_OPENGL_ES_API); } else { attribs[i++] = EGL_OPENGL_BIT; _this->egl_data->eglBindAPI(EGL_OPENGL_API); } if (_this->egl_data->egl_surfacetype) { attribs[i++] = EGL_SURFACE_TYPE; attribs[i++] = _this->egl_data->egl_surfacetype; } attribs[i++] = EGL_NONE; SDL_assert(i < SDL_arraysize(attribs)); if (_this->egl_data->eglChooseConfig(_this->egl_data->egl_display, attribs, configs, SDL_arraysize(configs), &found_configs) == EGL_FALSE || found_configs == 0) { return -1; } /* first ensure that a found config has a matching format, or the function will fall through. */ if (_this->egl_data->egl_required_visual_id) { for (i = 0; i < found_configs; i++) { EGLint format; _this->egl_data->eglGetConfigAttrib(_this->egl_data->egl_display, configs[i], EGL_NATIVE_VISUAL_ID, &format); if (_this->egl_data->egl_required_visual_id == format) { has_matching_format = SDL_TRUE; break; } } } /* eglChooseConfig returns a number of configurations that match or exceed the requested attribs. */ /* From those, we select the one that matches our requirements more closely via a makeshift algorithm */ for (i = 0; i < found_configs; i++) { SDL_bool is_truecolor = SDL_FALSE; int bitdiff = 0; if (has_matching_format && _this->egl_data->egl_required_visual_id) { EGLint format; _this->egl_data->eglGetConfigAttrib(_this->egl_data->egl_display, configs[i], EGL_NATIVE_VISUAL_ID, &format); if (_this->egl_data->egl_required_visual_id != format) { continue; } } _this->egl_data->eglGetConfigAttrib(_this->egl_data->egl_display, configs[i], EGL_RED_SIZE, &value); if (value == 8) { _this->egl_data->eglGetConfigAttrib(_this->egl_data->egl_display, configs[i], EGL_GREEN_SIZE, &value); if (value == 8) { _this->egl_data->eglGetConfigAttrib(_this->egl_data->egl_display, configs[i], EGL_BLUE_SIZE, &value); if (value == 8) { is_truecolor = SDL_TRUE; } } } for (j = 0; j < SDL_arraysize(attribs) - 1; j += 2) { if (attribs[j] == EGL_NONE) { break; } if (attribs[j + 1] != EGL_DONT_CARE && (attribs[j] == EGL_RED_SIZE || attribs[j] == EGL_GREEN_SIZE || attribs[j] == EGL_BLUE_SIZE || attribs[j] == EGL_ALPHA_SIZE || attribs[j] == EGL_DEPTH_SIZE || attribs[j] == EGL_STENCIL_SIZE)) { _this->egl_data->eglGetConfigAttrib(_this->egl_data->egl_display, configs[i], attribs[j], &value); bitdiff += value - attribs[j + 1]; /* value is always >= attrib */ } } if ((bitdiff < best_bitdiff) || (best_bitdiff == -1)) { _this->egl_data->egl_config = configs[i]; best_bitdiff = bitdiff; } if (is_truecolor && ((bitdiff < best_truecolor_bitdiff) || (best_truecolor_bitdiff == -1))) { truecolor_config_idx = i; best_truecolor_bitdiff = bitdiff; } } #define FAVOR_TRUECOLOR 1 #if FAVOR_TRUECOLOR /* Some apps request a low color depth, either because they _assume_ they'll get a larger one but don't want to fail if only smaller ones are available, or they just never called SDL_GL_SetAttribute at all and got a tiny default. For these cases, a game that would otherwise run at 24-bit color might get dithered down to something smaller, which is worth avoiding. If the app requested <= 16 bit color and an exact 24-bit match is available, favor that. Otherwise, we look for the closest match. Note that while the API promises what you request _or better_, it's feasible this can be disastrous for performance for custom software on small hardware that all expected to actually get 16-bit color. In this case, turn off FAVOR_TRUECOLOR (and maybe send a patch to make this more flexible). */ if (((_this->gl_config.red_size + _this->gl_config.blue_size + _this->gl_config.green_size) <= 16)) { if (truecolor_config_idx != -1) { _this->egl_data->egl_config = configs[truecolor_config_idx]; } } #endif #ifdef DUMP_EGL_CONFIG dumpconfig(_this, _this->egl_data->egl_config); #endif return 0; } int SDL_EGL_ChooseConfig(SDL_VideoDevice *_this) { int ret; if (!_this->egl_data) { return SDL_SetError("EGL not initialized"); } /* Try with EGL_CONFIG_CAVEAT set to EGL_NONE, to avoid any EGL_SLOW_CONFIG or EGL_NON_CONFORMANT_CONFIG */ ret = SDL_EGL_PrivateChooseConfig(_this, SDL_TRUE); if (ret == 0) { return 0; } /* Fallback with all configs */ ret = SDL_EGL_PrivateChooseConfig(_this, SDL_FALSE); if (ret == 0) { SDL_Log("SDL_EGL_ChooseConfig: found a slow EGL config"); return 0; } return SDL_EGL_SetError("Couldn't find matching EGL config", "eglChooseConfig"); } SDL_GLContext SDL_EGL_CreateContext(SDL_VideoDevice *_this, EGLSurface egl_surface) { /* max 16 key+value pairs plus terminator. */ EGLint attribs[33]; int attr = 0; EGLContext egl_context, share_context = EGL_NO_CONTEXT; EGLint profile_mask = _this->gl_config.profile_mask; EGLint major_version = _this->gl_config.major_version; EGLint minor_version = _this->gl_config.minor_version; SDL_bool profile_es = (profile_mask == SDL_GL_CONTEXT_PROFILE_ES); if (!_this->egl_data) { SDL_SetError("EGL not initialized"); return NULL; } if (_this->gl_config.share_with_current_context) { share_context = (EGLContext)SDL_GL_GetCurrentContext(); } #ifdef SDL_VIDEO_DRIVER_ANDROID if (_this->gl_config.flags & SDL_GL_CONTEXT_DEBUG_FLAG) { /* If SDL_GL_CONTEXT_DEBUG_FLAG is set but EGL_KHR_debug unsupported, unset. * This is required because some Android devices like to complain about it * by "silently" failing, logging a hint which could be easily overlooked: * E/libEGL (26984): validate_display:255 error 3008 (EGL_BAD_DISPLAY) * The following explicitly checks for EGL_KHR_debug before EGL 1.5 */ int egl_version_major = _this->egl_data->egl_version_major; int egl_version_minor = _this->egl_data->egl_version_minor; if (((egl_version_major < 1) || (egl_version_major == 1 && egl_version_minor < 5)) && !SDL_EGL_HasExtension(_this, SDL_EGL_DISPLAY_EXTENSION, "EGL_KHR_debug")) { /* SDL profile bits match EGL profile bits. */ _this->gl_config.flags &= ~SDL_GL_CONTEXT_DEBUG_FLAG; } } #endif /* Set the context version and other attributes. */ if ((major_version < 3 || (minor_version == 0 && profile_es)) && _this->gl_config.flags == 0 && (profile_mask == 0 || profile_es)) { /* Create a context without using EGL_KHR_create_context attribs. * When creating a GLES context without EGL_KHR_create_context we can * only specify the major version. When creating a desktop GL context * we can't specify any version, so we only try in that case when the * version is less than 3.0 (matches SDL's GLX/WGL behavior.) */ if (profile_es) { attribs[attr++] = EGL_CONTEXT_CLIENT_VERSION; attribs[attr++] = SDL_max(major_version, 1); } } else { #ifdef EGL_KHR_create_context /* The Major/minor version, context profiles, and context flags can * only be specified when this extension is available. */ if (SDL_EGL_HasExtension(_this, SDL_EGL_DISPLAY_EXTENSION, "EGL_KHR_create_context")) { attribs[attr++] = EGL_CONTEXT_MAJOR_VERSION_KHR; attribs[attr++] = major_version; attribs[attr++] = EGL_CONTEXT_MINOR_VERSION_KHR; attribs[attr++] = minor_version; /* SDL profile bits match EGL profile bits. */ if (profile_mask != 0 && profile_mask != SDL_GL_CONTEXT_PROFILE_ES) { attribs[attr++] = EGL_CONTEXT_OPENGL_PROFILE_MASK_KHR; attribs[attr++] = profile_mask; } /* SDL flags match EGL flags. */ if (_this->gl_config.flags != 0) { attribs[attr++] = EGL_CONTEXT_FLAGS_KHR; attribs[attr++] = _this->gl_config.flags; } } else #endif /* EGL_KHR_create_context */ { SDL_SetError("Could not create EGL context (context attributes are not supported)"); return NULL; } } #ifdef EGL_KHR_create_context_no_error if (_this->gl_config.no_error) { if (SDL_EGL_HasExtension(_this, SDL_EGL_DISPLAY_EXTENSION, "EGL_KHR_create_context_no_error")) { attribs[attr++] = EGL_CONTEXT_OPENGL_NO_ERROR_KHR; attribs[attr++] = _this->gl_config.no_error; } } #endif if (_this->egl_contextattrib_callback) { const int maxAttribs = sizeof(attribs) / sizeof(attribs[0]); EGLint *userAttribs, *userAttribP; userAttribs = _this->egl_contextattrib_callback(); if (!userAttribs) { _this->gl_config.driver_loaded = 0; *_this->gl_config.driver_path = '\0'; SDL_SetError("EGL context attribute callback returned NULL pointer"); return NULL; } for (userAttribP = userAttribs; *userAttribP != EGL_NONE;) { if (attr + 3 >= maxAttribs) { _this->gl_config.driver_loaded = 0; *_this->gl_config.driver_path = '\0'; SDL_SetError("EGL context attribute callback returned too many attributes"); return NULL; } attribs[attr++] = *userAttribP++; attribs[attr++] = *userAttribP++; } } attribs[attr++] = EGL_NONE; /* Bind the API */ if (profile_es) { _this->egl_data->apitype = EGL_OPENGL_ES_API; } else { _this->egl_data->apitype = EGL_OPENGL_API; } _this->egl_data->eglBindAPI(_this->egl_data->apitype); egl_context = _this->egl_data->eglCreateContext(_this->egl_data->egl_display, _this->egl_data->egl_config, share_context, attribs); if (egl_context == EGL_NO_CONTEXT) { SDL_EGL_SetError("Could not create EGL context", "eglCreateContext"); return NULL; } _this->egl_data->egl_swapinterval = 0; if (SDL_EGL_MakeCurrent(_this, egl_surface, egl_context) < 0) { /* Delete the context */ SDL_EGL_DeleteContext(_this, egl_context); return NULL; } /* Check whether making contexts current without a surface is supported. * First condition: EGL must support it. That's the case for EGL 1.5 * or later, or if the EGL_KHR_surfaceless_context extension is present. */ if ((_this->egl_data->egl_version_major > 1) || ((_this->egl_data->egl_version_major == 1) && (_this->egl_data->egl_version_minor >= 5)) || SDL_EGL_HasExtension(_this, SDL_EGL_DISPLAY_EXTENSION, "EGL_KHR_surfaceless_context")) { /* Secondary condition: The client API must support it. */ if (profile_es) { /* On OpenGL ES, the GL_OES_surfaceless_context extension must be * present. */ if (SDL_GL_ExtensionSupported("GL_OES_surfaceless_context")) { _this->gl_allow_no_surface = SDL_TRUE; } #if defined(SDL_VIDEO_OPENGL) && !defined(SDL_VIDEO_DRIVER_VITA) } else { /* Desktop OpenGL supports it by default from version 3.0 on. */ PFNGLGETINTEGERVPROC glGetIntegervFunc = (PFNGLGETINTEGERVPROC)SDL_GL_GetProcAddress("glGetIntegerv"); if (glGetIntegervFunc) { GLint v = 0; glGetIntegervFunc(GL_MAJOR_VERSION, &v); if (v >= 3) { _this->gl_allow_no_surface = SDL_TRUE; } } #endif } } return (SDL_GLContext)egl_context; } int SDL_EGL_MakeCurrent(SDL_VideoDevice *_this, EGLSurface egl_surface, SDL_GLContext context) { EGLContext egl_context = (EGLContext)context; if (!_this->egl_data) { return SDL_SetError("EGL not initialized"); } if (!_this->egl_data->eglMakeCurrent) { if (!egl_surface && !context) { /* Can't do the nothing there is to do? Probably trying to cleanup a failed startup, just return. */ return 0; } else { return SDL_SetError("EGL not initialized"); /* something clearly went wrong somewhere. */ } } /* Make sure current thread has a valid API bound to it. */ if (_this->egl_data->eglBindAPI) { _this->egl_data->eglBindAPI(_this->egl_data->apitype); } /* The android emulator crashes badly if you try to eglMakeCurrent * with a valid context and invalid surface, so we have to check for both here. */ if (!egl_context || (!egl_surface && !_this->gl_allow_no_surface)) { _this->egl_data->eglMakeCurrent(_this->egl_data->egl_display, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT); } else { if (!_this->egl_data->eglMakeCurrent(_this->egl_data->egl_display, egl_surface, egl_surface, egl_context)) { return SDL_EGL_SetError("Unable to make EGL context current", "eglMakeCurrent"); } } return 0; } int SDL_EGL_SetSwapInterval(SDL_VideoDevice *_this, int interval) { EGLBoolean status; if (!_this->egl_data) { return SDL_SetError("EGL not initialized"); } /* FIXME: Revisit this check when EGL_EXT_swap_control_tear is published: * https://github.com/KhronosGroup/EGL-Registry/pull/113 */ if (interval < 0) { return SDL_SetError("Late swap tearing currently unsupported"); } status = _this->egl_data->eglSwapInterval(_this->egl_data->egl_display, interval); if (status == EGL_TRUE) { _this->egl_data->egl_swapinterval = interval; return 0; } return SDL_EGL_SetError("Unable to set the EGL swap interval", "eglSwapInterval"); } int SDL_EGL_GetSwapInterval(SDL_VideoDevice *_this, int *interval) { if (!_this->egl_data) { return SDL_SetError("EGL not initialized"); } *interval = _this->egl_data->egl_swapinterval; return 0; } int SDL_EGL_SwapBuffers(SDL_VideoDevice *_this, EGLSurface egl_surface) { if (!_this->egl_data->eglSwapBuffers(_this->egl_data->egl_display, egl_surface)) { return SDL_EGL_SetError("unable to show color buffer in an OS-native window", "eglSwapBuffers"); } return 0; } int SDL_EGL_DeleteContext(SDL_VideoDevice *_this, SDL_GLContext context) { EGLContext egl_context = (EGLContext)context; /* Clean up GLES and EGL */ if (!_this->egl_data) { return 0; } if (egl_context != NULL && egl_context != EGL_NO_CONTEXT) { _this->egl_data->eglDestroyContext(_this->egl_data->egl_display, egl_context); } return 0; } EGLSurface *SDL_EGL_CreateSurface(SDL_VideoDevice *_this, SDL_Window *window, NativeWindowType nw) { #ifdef SDL_VIDEO_DRIVER_ANDROID EGLint format_wanted; EGLint format_got; #endif /* max 16 key+value pairs, plus terminator. */ EGLint attribs[33]; int attr = 0; EGLSurface *surface; if (SDL_EGL_ChooseConfig(_this) != 0) { return EGL_NO_SURFACE; } #ifdef SDL_VIDEO_DRIVER_ANDROID /* On Android, EGL_NATIVE_VISUAL_ID is an attribute of the EGLConfig that is * guaranteed to be accepted by ANativeWindow_setBuffersGeometry(). */ _this->egl_data->eglGetConfigAttrib(_this->egl_data->egl_display, _this->egl_data->egl_config, EGL_NATIVE_VISUAL_ID, &format_wanted); /* Format based on selected egl config. */ ANativeWindow_setBuffersGeometry(nw, 0, 0, format_wanted); #endif if (_this->gl_config.framebuffer_srgb_capable) { #ifdef EGL_KHR_gl_colorspace if (SDL_EGL_HasExtension(_this, SDL_EGL_DISPLAY_EXTENSION, "EGL_KHR_gl_colorspace")) { attribs[attr++] = EGL_GL_COLORSPACE_KHR; attribs[attr++] = EGL_GL_COLORSPACE_SRGB_KHR; } else #endif { SDL_SetError("EGL implementation does not support sRGB system framebuffers"); return EGL_NO_SURFACE; } } #ifdef EGL_EXT_present_opaque if (SDL_EGL_HasExtension(_this, SDL_EGL_DISPLAY_EXTENSION, "EGL_EXT_present_opaque")) { SDL_bool allow_transparent = SDL_FALSE; if (window && (window->flags & SDL_WINDOW_TRANSPARENT)) { allow_transparent = SDL_TRUE; } attribs[attr++] = EGL_PRESENT_OPAQUE_EXT; attribs[attr++] = allow_transparent ? EGL_FALSE : EGL_TRUE; } #endif if (_this->egl_surfaceattrib_callback) { const int maxAttribs = sizeof(attribs) / sizeof(attribs[0]); EGLint *userAttribs, *userAttribP; userAttribs = _this->egl_surfaceattrib_callback(); if (!userAttribs) { _this->gl_config.driver_loaded = 0; *_this->gl_config.driver_path = '\0'; SDL_SetError("EGL surface attribute callback returned NULL pointer"); return EGL_NO_SURFACE; } for (userAttribP = userAttribs; *userAttribP != EGL_NONE;) { if (attr + 3 >= maxAttribs) { _this->gl_config.driver_loaded = 0; *_this->gl_config.driver_path = '\0'; SDL_SetError("EGL surface attribute callback returned too many attributes"); return EGL_NO_SURFACE; } attribs[attr++] = *userAttribP++; attribs[attr++] = *userAttribP++; } } attribs[attr++] = EGL_NONE; surface = _this->egl_data->eglCreateWindowSurface( _this->egl_data->egl_display, _this->egl_data->egl_config, nw, &attribs[0]); if (surface == EGL_NO_SURFACE) { SDL_EGL_SetError("unable to create an EGL window surface", "eglCreateWindowSurface"); } #ifdef SDL_VIDEO_DRIVER_ANDROID format_got = ANativeWindow_getFormat(nw); Android_SetFormat(format_wanted, format_got); #endif return surface; } EGLSurface SDL_EGL_CreateOffscreenSurface(SDL_VideoDevice *_this, int width, int height) { EGLint attributes[] = { EGL_WIDTH, 0, EGL_HEIGHT, 0, EGL_NONE }; attributes[1] = width; attributes[3] = height; if (SDL_EGL_ChooseConfig(_this) != 0) { return EGL_NO_SURFACE; } return _this->egl_data->eglCreatePbufferSurface( _this->egl_data->egl_display, _this->egl_data->egl_config, attributes); } void SDL_EGL_DestroySurface(SDL_VideoDevice *_this, EGLSurface egl_surface) { if (!_this->egl_data) { return; } if (egl_surface != EGL_NO_SURFACE) { _this->egl_data->eglDestroySurface(_this->egl_data->egl_display, egl_surface); } } #endif /* SDL_VIDEO_OPENGL_EGL */