AuroraMiddleware/gtk
1
0
Fork 1
mirror of https://gitlab.gnome.org/GNOME/gtk.git synced 2024-11-14 04:31:09 +00:00
Code Issues Projects Releases Wiki Activity
bfb158d773
gtk/gdk/x11/gdkglcontext-egl.c

857 lines
26 KiB
C
Raw Normal View History

x11: Use EGL for GL support This makes the X11 backend similar to the Wayland one, when it comes to OpenGL. Fall back to GLX only if EGL support is not available.
2021-05-10 17:11:05 +00:00
/* GDK - The GIMP Drawing Kit
*
x11: Move the damage fences into the GLX code It's GLX-specific anyway, there's no need to complicate things by having half the code in the generic path, and half in the GLX one.
2021-05-10 19:33:02 +00:00
* gdkglcontext-egl.c: EGL-X11 specific wrappers
x11: Use EGL for GL support This makes the X11 backend similar to the Wayland one, when it comes to OpenGL. Fall back to GLX only if EGL support is not available.
2021-05-10 17:11:05 +00:00
*
x11: Move the damage fences into the GLX code It's GLX-specific anyway, there's no need to complicate things by having half the code in the generic path, and half in the GLX one.
2021-05-10 19:33:02 +00:00
* SPDX-FileCopyrightText: 2014 Emmanuele Bassi
* SPDX-FileCopyrightText: 2021 GNOME Foundation
x11: Use EGL for GL support This makes the X11 backend similar to the Wayland one, when it comes to OpenGL. Fall back to GLX only if EGL support is not available.
2021-05-10 17:11:05 +00:00
*
x11: Move the damage fences into the GLX code It's GLX-specific anyway, there's no need to complicate things by having half the code in the generic path, and half in the GLX one.
2021-05-10 19:33:02 +00:00
* SPDX-License-Identifier: LGPL-2.1-or-later
x11: Use EGL for GL support This makes the X11 backend similar to the Wayland one, when it comes to OpenGL. Fall back to GLX only if EGL support is not available.
2021-05-10 17:11:05 +00:00
*/
#include "config.h"
#include "gdkglcontext-x11.h"
#include "gdkdisplay-x11.h"
#include "gdkprivate-x11.h"
#include "gdkscreen-x11.h"
#include "gdkx11display.h"
#include "gdkx11glcontext.h"
#include "gdkx11screen.h"
#include "gdkx11surface.h"
#include "gdkx11property.h"
#include <X11/Xatom.h>
x11: Add profiler marks for SwapBuffers
2021-05-10 17:22:34 +00:00
#include "gdkprofilerprivate.h"
x11: Use EGL for GL support This makes the X11 backend similar to the Wayland one, when it comes to OpenGL. Fall back to GLX only if EGL support is not available.
2021-05-10 17:11:05 +00:00
#include "gdkintl.h"
#include <cairo-xlib.h>
#include <epoxy/egl.h>
struct _GdkX11GLContextEGL
{
GdkX11GLContext parent_instance;
EGLContext egl_context;
x11: Move code from GdkGLContextX11 It's not used there, but both backends have independent immplementationgs for it. I want to get rid of GdkGLContextX11 and moving code from it is the first step.
2021-07-13 03:04:45 +00:00
guint do_frame_sync : 1;
x11: Use EGL for GL support This makes the X11 backend similar to the Wayland one, when it comes to OpenGL. Fall back to GLX only if EGL support is not available.
2021-05-10 17:11:05 +00:00
};
typedef struct _GdkX11GLContextClass GdkX11GLContextEGLClass;
G_DEFINE_TYPE (GdkX11GLContextEGL, gdk_x11_gl_context_egl, GDK_TYPE_X11_GL_CONTEXT)
x11: Add EGLDisplay getter Getting an EGLDisplay object is messy; might as well expose the function we use internally to save some time.
2021-05-11 11:25:38 +00:00
/**
* gdk_x11_display_get_egl_display:
* @display: (type GdkX11Display): an X11 display
*
* Retrieves the EGL display connection object for the given GDK display.
*
* This function returns `NULL` if GDK is using GLX.
*
* Returns: (nullable): the EGL display object
*
* Since: 4.4
*/
gpointer
x11: Use EGL for GL support This makes the X11 backend similar to the Wayland one, when it comes to OpenGL. Fall back to GLX only if EGL support is not available.
2021-05-10 17:11:05 +00:00
gdk_x11_display_get_egl_display (GdkDisplay *display)
{
x11: Move the EGL display into the private struct There's no need to use g_object_set_data() for it. We can also stop caching it elsewhere because we know the display has it. And finally, we can remove the display->have_egl boolean and use display->egl_display != NULL instead. We initialize the display at startup, so that variable is the perfect indicator.
2021-06-07 12:30:29 +00:00
GdkX11Display *self;
x11: Use EGL for GL support This makes the X11 backend similar to the Wayland one, when it comes to OpenGL. Fall back to GLX only if EGL support is not available.
2021-05-10 17:11:05 +00:00
x11: Add EGLDisplay getter Getting an EGLDisplay object is messy; might as well expose the function we use internally to save some time.
2021-05-11 11:25:38 +00:00
g_return_val_if_fail (GDK_IS_X11_DISPLAY (display), NULL);
x11: Move the EGL display into the private struct There's no need to use g_object_set_data() for it. We can also stop caching it elsewhere because we know the display has it. And finally, we can remove the display->have_egl boolean and use display->egl_display != NULL instead. We initialize the display at startup, so that variable is the perfect indicator.
2021-06-07 12:30:29 +00:00
self = GDK_X11_DISPLAY (display);
x11: Add EGLDisplay getter Getting an EGLDisplay object is messy; might as well expose the function we use internally to save some time.
2021-05-11 11:25:38 +00:00
x11: Move the EGL display into the private struct There's no need to use g_object_set_data() for it. We can also stop caching it elsewhere because we know the display has it. And finally, we can remove the display->have_egl boolean and use display->egl_display != NULL instead. We initialize the display at startup, so that variable is the perfect indicator.
2021-06-07 12:30:29 +00:00
return self->egl_display;
}
x11: Use EGL for GL support This makes the X11 backend similar to the Wayland one, when it comes to OpenGL. Fall back to GLX only if EGL support is not available.
2021-05-10 17:11:05 +00:00
x11: Move the EGL display into the private struct There's no need to use g_object_set_data() for it. We can also stop caching it elsewhere because we know the display has it. And finally, we can remove the display->have_egl boolean and use display->egl_display != NULL instead. We initialize the display at startup, so that variable is the perfect indicator.
2021-06-07 12:30:29 +00:00
static void
gdk_x11_display_create_egl_display (GdkX11Display *self)
{
Display *dpy;
g_assert (self->egl_display == NULL);
dpy = gdk_x11_display_get_xdisplay (GDK_DISPLAY (self));
x11: Use EGL for GL support This makes the X11 backend similar to the Wayland one, when it comes to OpenGL. Fall back to GLX only if EGL support is not available.
2021-05-10 17:11:05 +00:00
if (epoxy_has_egl_extension (NULL, "EGL_KHR_platform_base"))
{
PFNEGLGETPLATFORMDISPLAYPROC getPlatformDisplay =
(void *) eglGetProcAddress ("eglGetPlatformDisplay");
if (getPlatformDisplay != NULL)
x11: Move the EGL display into the private struct There's no need to use g_object_set_data() for it. We can also stop caching it elsewhere because we know the display has it. And finally, we can remove the display->have_egl boolean and use display->egl_display != NULL instead. We initialize the display at startup, so that variable is the perfect indicator.
2021-06-07 12:30:29 +00:00
self->egl_display = getPlatformDisplay (EGL_PLATFORM_X11_KHR, dpy, NULL);
x11: Use EGL for GL support This makes the X11 backend similar to the Wayland one, when it comes to OpenGL. Fall back to GLX only if EGL support is not available.
2021-05-10 17:11:05 +00:00
x11: Move the EGL display into the private struct There's no need to use g_object_set_data() for it. We can also stop caching it elsewhere because we know the display has it. And finally, we can remove the display->have_egl boolean and use display->egl_display != NULL instead. We initialize the display at startup, so that variable is the perfect indicator.
2021-06-07 12:30:29 +00:00
if (self->egl_display != NULL)
return;
x11: Use EGL for GL support This makes the X11 backend similar to the Wayland one, when it comes to OpenGL. Fall back to GLX only if EGL support is not available.
2021-05-10 17:11:05 +00:00
}
if (epoxy_has_egl_extension (NULL, "EGL_EXT_platform_base"))
{
PFNEGLGETPLATFORMDISPLAYEXTPROC getPlatformDisplay =
(void *) eglGetProcAddress ("eglGetPlatformDisplayEXT");
if (getPlatformDisplay)
x11: Move the EGL display into the private struct There's no need to use g_object_set_data() for it. We can also stop caching it elsewhere because we know the display has it. And finally, we can remove the display->have_egl boolean and use display->egl_display != NULL instead. We initialize the display at startup, so that variable is the perfect indicator.
2021-06-07 12:30:29 +00:00
self->egl_display = getPlatformDisplay (EGL_PLATFORM_X11_EXT, dpy, NULL);
x11: Use EGL for GL support This makes the X11 backend similar to the Wayland one, when it comes to OpenGL. Fall back to GLX only if EGL support is not available.
2021-05-10 17:11:05 +00:00
x11: Move the EGL display into the private struct There's no need to use g_object_set_data() for it. We can also stop caching it elsewhere because we know the display has it. And finally, we can remove the display->have_egl boolean and use display->egl_display != NULL instead. We initialize the display at startup, so that variable is the perfect indicator.
2021-06-07 12:30:29 +00:00
if (self->egl_display != NULL)
return;
x11: Use EGL for GL support This makes the X11 backend similar to the Wayland one, when it comes to OpenGL. Fall back to GLX only if EGL support is not available.
2021-05-10 17:11:05 +00:00
}
x11: Move the EGL display into the private struct There's no need to use g_object_set_data() for it. We can also stop caching it elsewhere because we know the display has it. And finally, we can remove the display->have_egl boolean and use display->egl_display != NULL instead. We initialize the display at startup, so that variable is the perfect indicator.
2021-06-07 12:30:29 +00:00
self->egl_display = eglGetDisplay ((EGLNativeDisplayType) dpy);
x11: Use EGL for GL support This makes the X11 backend similar to the Wayland one, when it comes to OpenGL. Fall back to GLX only if EGL support is not available.
2021-05-10 17:11:05 +00:00
}
x11: Get Visual from EGL directly Query the EGL_VISUAL_ID from the egl Config and select a config with the matching Visual. This is currently broken on Mesa because it does not expose any RGBA X Visuals in any EGL config, so we always end up with opaque Windows. https://gitlab.freedesktop.org/mesa/mesa/-/issues/149
2021-06-18 12:46:24 +00:00
static XVisualInfo *
gdk_x11_display_get_visual_info_for_visual (GdkX11Display *self,
VisualID visualid)
{
XVisualInfo template, *visinfo;
int nvisuals;
template.screen = self->screen->screen_num;
template.visualid = visualid;
visinfo = XGetVisualInfo (gdk_x11_display_get_xdisplay (GDK_DISPLAY (self)),
VisualScreenMask | VisualIDMask,
&template,
&nvisuals);
g_warn_if_fail (nvisuals == 1);
return visinfo;
}
static gboolean
visual_is_rgba (XVisualInfo *visinfo)
{
return
visinfo->depth == 32 &&
visinfo->visual->red_mask == 0xff0000 &&
visinfo->visual->green_mask == 0x00ff00 &&
visinfo->visual->blue_mask == 0x0000ff;
}
x11: Store the EGL config in the display We only have one config, because we use the same Visual everywhere. Store this config in the GdkDisplayX11 struct for easy access. Also do this on initialize, because if creating the config fails, we want to switch to GLX instead of failing to do GL at all. This also simplifies a lot of code as we can share Visual, Colormap, etc across surfaces.
2021-06-09 11:42:19 +00:00
#define MAX_EGL_ATTRS 30
x11: Properly record the error when initializing GL That way, we can give a useful error message when things break down for users. These error messages could still be improved in places (like looking at the actual EGL error codes), but that seemed overkill.
2021-07-02 01:21:14 +00:00
static gboolean
x11: Get Visual from EGL directly Query the EGL_VISUAL_ID from the egl Config and select a config with the matching Visual. This is currently broken on Mesa because it does not expose any RGBA X Visuals in any EGL config, so we always end up with opaque Windows. https://gitlab.freedesktop.org/mesa/mesa/-/issues/149
2021-06-18 12:46:24 +00:00
gdk_x11_display_create_egl_config (GdkX11Display *display,
x11: Redo choice between EGL and GLX We try EGL first, but are very picky about what we accept. If that fails, we try to go with GLX instead. And if that also fails, we try EGL again, but this time accept anything. The idea here is that EGL is the preferred method going forward, but GLX is the tried and tested method that we know works. So if we detect issues with EGL, we want to avoid using it in favor of GLX. Also add a GDK_DEBUG=gl-egl option to force EGL at all costs and not try GLX.
2021-07-02 01:37:32 +00:00
gboolean force,
x11: Get Visual from EGL directly Query the EGL_VISUAL_ID from the egl Config and select a config with the matching Visual. This is currently broken on Mesa because it does not expose any RGBA X Visuals in any EGL config, so we always end up with opaque Windows. https://gitlab.freedesktop.org/mesa/mesa/-/issues/149
2021-06-18 12:46:24 +00:00
Visual **out_visual,
x11: Properly record the error when initializing GL That way, we can give a useful error message when things break down for users. These error messages could still be improved in places (like looking at the actual EGL error codes), but that seemed overkill.
2021-07-02 01:21:14 +00:00
int *out_depth,
GError **error)
x11: Store the EGL config in the display We only have one config, because we use the same Visual everywhere. Store this config in the GdkDisplayX11 struct for easy access. Also do this on initialize, because if creating the config fails, we want to switch to GLX instead of failing to do GL at all. This also simplifies a lot of code as we can share Visual, Colormap, etc across surfaces.
2021-06-09 11:42:19 +00:00
{
GdkX11Display *self = GDK_X11_DISPLAY (display);
EGLint attrs[MAX_EGL_ATTRS];
x11: Get Visual from EGL directly Query the EGL_VISUAL_ID from the egl Config and select a config with the matching Visual. This is currently broken on Mesa because it does not expose any RGBA X Visuals in any EGL config, so we always end up with opaque Windows. https://gitlab.freedesktop.org/mesa/mesa/-/issues/149
2021-06-18 12:46:24 +00:00
EGLConfig *configs;
EGLint count, alloced;
enum {
NO_VISUAL_FOUND,
WITH_MULTISAMPLING,
WITH_STENCIL_AND_DEPTH_BUFFER,
NO_ALPHA,
NO_ALPHA_VISUAL,
PERFECT
} best_features;
x11: Store the EGL config in the display We only have one config, because we use the same Visual everywhere. Store this config in the GdkDisplayX11 struct for easy access. Also do this on initialize, because if creating the config fails, we want to switch to GLX instead of failing to do GL at all. This also simplifies a lot of code as we can share Visual, Colormap, etc across surfaces.
2021-06-09 11:42:19 +00:00
int i = 0;
attrs[i++] = EGL_SURFACE_TYPE;
attrs[i++] = EGL_WINDOW_BIT;
attrs[i++] = EGL_COLOR_BUFFER_TYPE;
attrs[i++] = EGL_RGB_BUFFER;
attrs[i++] = EGL_RED_SIZE;
attrs[i++] = 8;
attrs[i++] = EGL_GREEN_SIZE;
attrs[i++] = 8;
attrs[i++] = EGL_BLUE_SIZE;
attrs[i++] = 8;
attrs[i++] = EGL_ALPHA_SIZE;
attrs[i++] = 8;
attrs[i++] = EGL_NONE;
g_assert (i < MAX_EGL_ATTRS);
x11: Properly record the error when initializing GL That way, we can give a useful error message when things break down for users. These error messages could still be improved in places (like looking at the actual EGL error codes), but that seemed overkill.
2021-07-02 01:21:14 +00:00
if (!eglChooseConfig (self->egl_display, attrs, NULL, -1, &alloced) || alloced == 0)
{
g_set_error_literal (error, GDK_GL_ERROR, GDK_GL_ERROR_NOT_AVAILABLE,
_("No EGL configuration available"));
return FALSE;
}
x11: Get Visual from EGL directly Query the EGL_VISUAL_ID from the egl Config and select a config with the matching Visual. This is currently broken on Mesa because it does not expose any RGBA X Visuals in any EGL config, so we always end up with opaque Windows. https://gitlab.freedesktop.org/mesa/mesa/-/issues/149
2021-06-18 12:46:24 +00:00
configs = g_new (EGLConfig, alloced);
if (!eglChooseConfig (self->egl_display, attrs, configs, alloced, &count))
{
x11: Properly record the error when initializing GL That way, we can give a useful error message when things break down for users. These error messages could still be improved in places (like looking at the actual EGL error codes), but that seemed overkill.
2021-07-02 01:21:14 +00:00
g_set_error_literal (error, GDK_GL_ERROR, GDK_GL_ERROR_NOT_AVAILABLE,
_("Failed to get EGL configurations"));
return FALSE;
x11: Get Visual from EGL directly Query the EGL_VISUAL_ID from the egl Config and select a config with the matching Visual. This is currently broken on Mesa because it does not expose any RGBA X Visuals in any EGL config, so we always end up with opaque Windows. https://gitlab.freedesktop.org/mesa/mesa/-/issues/149
2021-06-18 12:46:24 +00:00
}
g_warn_if_fail (alloced == count);
best_features = NO_VISUAL_FOUND;
for (i = 0; i < count; i++)
{
XVisualInfo *visinfo;
int tmp, visualid;
if (!eglGetConfigAttrib (self->egl_display, configs[i], EGL_NATIVE_VISUAL_ID, &visualid))
continue;
visinfo = gdk_x11_display_get_visual_info_for_visual (self, visualid);
if (visinfo == NULL)
continue;
if (!eglGetConfigAttrib (self->egl_display, configs[i], EGL_SAMPLE_BUFFERS, &tmp) || tmp != 0)
{
if (best_features < WITH_MULTISAMPLING)
{
GDK_NOTE (OPENGL, g_message ("Best EGL config is %u for visual 0x%lX with multisampling", i, visinfo->visualid));
best_features = WITH_MULTISAMPLING;
*out_visual = visinfo->visual;
*out_depth = visinfo->depth;
self->egl_config = configs[i];
}
XFree (visinfo);
continue;
}
if (!eglGetConfigAttrib (self->egl_display, configs[i], EGL_DEPTH_SIZE, &tmp) || tmp != 0 ||
!eglGetConfigAttrib (self->egl_display, configs[i], EGL_STENCIL_SIZE, &tmp) || tmp != 0)
{
GDK_NOTE (OPENGL, g_message ("Best EGL config is %u for visual 0x%lX with stencil or depth buffer", i, visinfo->visualid));
if (best_features < WITH_STENCIL_AND_DEPTH_BUFFER)
{
best_features = WITH_STENCIL_AND_DEPTH_BUFFER;
*out_visual = visinfo->visual;
*out_depth = visinfo->depth;
self->egl_config = configs[i];
}
XFree (visinfo);
continue;
}
if (!visual_is_rgba (visinfo))
{
GDK_NOTE (OPENGL, g_message ("Best EGL config is %u for visual 0x%lX without RGBA Visual", i, visinfo->visualid));
if (best_features < NO_ALPHA_VISUAL)
{
best_features = NO_ALPHA_VISUAL;
*out_visual = visinfo->visual;
*out_depth = visinfo->depth;
self->egl_config = configs[i];
}
XFree (visinfo);
continue;
}
GDK_NOTE (OPENGL, g_message ("EGL Config %u for visual 0x%lX is the perfect choice", i, visinfo->visualid));
*out_visual = visinfo->visual;
*out_depth = visinfo->depth;
self->egl_config = configs[i];
XFree (visinfo);
/* everything is perfect */
best_features = PERFECT;
break;
}
g_free (configs);
x11: Properly record the error when initializing GL That way, we can give a useful error message when things break down for users. These error messages could still be improved in places (like looking at the actual EGL error codes), but that seemed overkill.
2021-07-02 01:21:14 +00:00
if (best_features == NO_VISUAL_FOUND)
{
g_set_error_literal (error, GDK_GL_ERROR,
GDK_GL_ERROR_NOT_AVAILABLE,
_("No EGL configuration with required features found"));
return FALSE;
}
x11: Redo choice between EGL and GLX We try EGL first, but are very picky about what we accept. If that fails, we try to go with GLX instead. And if that also fails, we try EGL again, but this time accept anything. The idea here is that EGL is the preferred method going forward, but GLX is the tried and tested method that we know works. So if we detect issues with EGL, we want to avoid using it in favor of GLX. Also add a GDK_DEBUG=gl-egl option to force EGL at all costs and not try GLX.
2021-07-02 01:37:32 +00:00
else if (!force && best_features != PERFECT)
{
g_set_error_literal (error, GDK_GL_ERROR,
GDK_GL_ERROR_NOT_AVAILABLE,
_("No perfect EGL configuration found"));
return FALSE;
}
x11: Properly record the error when initializing GL That way, we can give a useful error message when things break down for users. These error messages could still be improved in places (like looking at the actual EGL error codes), but that seemed overkill.
2021-07-02 01:21:14 +00:00
return TRUE;
x11: Store the EGL config in the display We only have one config, because we use the same Visual everywhere. Store this config in the GdkDisplayX11 struct for easy access. Also do this on initialize, because if creating the config fails, we want to switch to GLX instead of failing to do GL at all. This also simplifies a lot of code as we can share Visual, Colormap, etc across surfaces.
2021-06-09 11:42:19 +00:00
}
#undef MAX_EGL_ATTRS
x11: Use EGL for GL support This makes the X11 backend similar to the Wayland one, when it comes to OpenGL. Fall back to GLX only if EGL support is not available.
2021-05-10 17:11:05 +00:00
static EGLSurface
x11: Store the EGL config in the display We only have one config, because we use the same Visual everywhere. Store this config in the GdkDisplayX11 struct for easy access. Also do this on initialize, because if creating the config fails, we want to switch to GLX instead of failing to do GL at all. This also simplifies a lot of code as we can share Visual, Colormap, etc across surfaces.
2021-06-09 11:42:19 +00:00
gdk_x11_surface_get_egl_surface (GdkSurface *surface)
x11: Use EGL for GL support This makes the X11 backend similar to the Wayland one, when it comes to OpenGL. Fall back to GLX only if EGL support is not available.
2021-05-10 17:11:05 +00:00
{
x11: Store the EGL surface in the GdkSurfaceX11 Avoids having to use private data, though the benefit is somewhat limited as we still have to put the destructor in the egl code and can't just put it in gdk_surface_x11_finalize().
2021-06-10 21:10:22 +00:00
GdkX11Surface *self = GDK_X11_SURFACE (surface);
GdkDisplay *display = gdk_surface_get_display (GDK_SURFACE (self));
x11: Move the EGL display into the private struct There's no need to use g_object_set_data() for it. We can also stop caching it elsewhere because we know the display has it. And finally, we can remove the display->have_egl boolean and use display->egl_display != NULL instead. We initialize the display at startup, so that variable is the perfect indicator.
2021-06-07 12:30:29 +00:00
GdkX11Display *display_x11 = GDK_X11_DISPLAY (display);
x11: Use EGL for GL support This makes the X11 backend similar to the Wayland one, when it comes to OpenGL. Fall back to GLX only if EGL support is not available.
2021-05-10 17:11:05 +00:00
x11: Store the EGL surface in the GdkSurfaceX11 Avoids having to use private data, though the benefit is somewhat limited as we still have to put the destructor in the egl code and can't just put it in gdk_surface_x11_finalize().
2021-06-10 21:10:22 +00:00
if (self->egl_surface)
return self->egl_surface;
x11: Use EGL for GL support This makes the X11 backend similar to the Wayland one, when it comes to OpenGL. Fall back to GLX only if EGL support is not available.
2021-05-10 17:11:05 +00:00
x11: Store the EGL surface in the GdkSurfaceX11 Avoids having to use private data, though the benefit is somewhat limited as we still have to put the destructor in the egl code and can't just put it in gdk_surface_x11_finalize().
2021-06-10 21:10:22 +00:00
self->egl_surface =
eglCreateWindowSurface (display_x11->egl_display,
display_x11->egl_config,
x11: Use EGL for GL support This makes the X11 backend similar to the Wayland one, when it comes to OpenGL. Fall back to GLX only if EGL support is not available.
2021-05-10 17:11:05 +00:00
(EGLNativeWindowType) gdk_x11_surface_get_xid (surface),
NULL);
x11: Store the EGL surface in the GdkSurfaceX11 Avoids having to use private data, though the benefit is somewhat limited as we still have to put the destructor in the egl code and can't just put it in gdk_surface_x11_finalize().
2021-06-10 21:10:22 +00:00
return self->egl_surface;
}
x11: Use EGL for GL support This makes the X11 backend similar to the Wayland one, when it comes to OpenGL. Fall back to GLX only if EGL support is not available.
2021-05-10 17:11:05 +00:00
x11: Store the EGL surface in the GdkSurfaceX11 Avoids having to use private data, though the benefit is somewhat limited as we still have to put the destructor in the egl code and can't just put it in gdk_surface_x11_finalize().
2021-06-10 21:10:22 +00:00
void
gdk_x11_surface_destroy_egl_surface (GdkX11Surface *self)
{
GdkX11Display *display_x11;
if (self->egl_surface == NULL)
return;
display_x11 = GDK_X11_DISPLAY (gdk_surface_get_display (GDK_SURFACE (self)));
eglDestroySurface (display_x11->egl_display, self->egl_surface);
self->egl_surface = NULL;
x11: Use EGL for GL support This makes the X11 backend similar to the Wayland one, when it comes to OpenGL. Fall back to GLX only if EGL support is not available.
2021-05-10 17:11:05 +00:00
}
gl: Fix issue with EGL + nvidia nvidia sets the default draw buffer to GL_NONE if EGL contexts are initially bound to EGL_NO_SURFACE which is exactly what we are doing. So bind them to GL_BACK when drawing, as they should be. See https://phabricator.services.mozilla.com/D118743 for a discussion about EGL_NO_CONTEXT and draw buffers.
2021-07-10 00:29:17 +00:00
static void
gdk_x11_gl_context_egl_begin_frame (GdkDrawContext *draw_context,
cairo_region_t *region)
{
GDK_DRAW_CONTEXT_CLASS (gdk_x11_gl_context_egl_parent_class)->begin_frame (draw_context, region);
glDrawBuffers (1, (GLenum[1]) { GL_BACK });
}
x11: Use EGL for GL support This makes the X11 backend similar to the Wayland one, when it comes to OpenGL. Fall back to GLX only if EGL support is not available.
2021-05-10 17:11:05 +00:00
static void
gdk_x11_gl_context_egl_end_frame (GdkDrawContext *draw_context,
cairo_region_t *painted)
{
GdkGLContext *context = GDK_GL_CONTEXT (draw_context);
GdkSurface *surface = gdk_gl_context_get_surface (context);
GdkDisplay *display = gdk_surface_get_display (surface);
GdkX11Display *display_x11 = GDK_X11_DISPLAY (display);
EGLSurface egl_surface;
GDK_DRAW_CONTEXT_CLASS (gdk_x11_gl_context_egl_parent_class)->end_frame (draw_context, painted);
gdk_gl_context_make_current (context);
x11: Store the EGL config in the display We only have one config, because we use the same Visual everywhere. Store this config in the GdkDisplayX11 struct for easy access. Also do this on initialize, because if creating the config fails, we want to switch to GLX instead of failing to do GL at all. This also simplifies a lot of code as we can share Visual, Colormap, etc across surfaces.
2021-06-09 11:42:19 +00:00
egl_surface = gdk_x11_surface_get_egl_surface (surface);
x11: Use EGL for GL support This makes the X11 backend similar to the Wayland one, when it comes to OpenGL. Fall back to GLX only if EGL support is not available.
2021-05-10 17:11:05 +00:00
x11: Add profiler marks for SwapBuffers
2021-05-10 17:22:34 +00:00
gdk_profiler_add_mark (GDK_PROFILER_CURRENT_TIME, 0, "x11", "swap buffers");
x11: Use EGL for GL support This makes the X11 backend similar to the Wayland one, when it comes to OpenGL. Fall back to GLX only if EGL support is not available.
2021-05-10 17:11:05 +00:00
if (display_x11->has_egl_swap_buffers_with_damage)
{
int i, j, n_rects = cairo_region_num_rectangles (painted);
int surface_height = gdk_surface_get_height (surface);
int scale = gdk_surface_get_scale_factor (surface);
EGLint stack_rects[4 * 4]; /* 4 rects */
EGLint *heap_rects = NULL;
EGLint *rects;
if (n_rects < G_N_ELEMENTS (stack_rects) / 4)
rects = (EGLint *) &stack_rects;
else
rects = heap_rects = g_new (EGLint, n_rects * 4);
for (i = 0, j = 0; i < n_rects; i++)
{
cairo_rectangle_int_t rect;
cairo_region_get_rectangle (painted, i, &rect);
rects[j++] = rect.x * scale;
rects[j++] = (surface_height - rect.height - rect.y) * scale;
rects[j++] = rect.width * scale;
rects[j++] = rect.height * scale;
}
x11: Move the EGL display into the private struct There's no need to use g_object_set_data() for it. We can also stop caching it elsewhere because we know the display has it. And finally, we can remove the display->have_egl boolean and use display->egl_display != NULL instead. We initialize the display at startup, so that variable is the perfect indicator.
2021-06-07 12:30:29 +00:00
eglSwapBuffersWithDamageEXT (display_x11->egl_display, egl_surface, rects, n_rects);
x11: Use EGL for GL support This makes the X11 backend similar to the Wayland one, when it comes to OpenGL. Fall back to GLX only if EGL support is not available.
2021-05-10 17:11:05 +00:00
g_free (heap_rects);
}
else
x11: Move the EGL display into the private struct There's no need to use g_object_set_data() for it. We can also stop caching it elsewhere because we know the display has it. And finally, we can remove the display->have_egl boolean and use display->egl_display != NULL instead. We initialize the display at startup, so that variable is the perfect indicator.
2021-06-07 12:30:29 +00:00
eglSwapBuffers (display_x11->egl_display, egl_surface);
x11: Use EGL for GL support This makes the X11 backend similar to the Wayland one, when it comes to OpenGL. Fall back to GLX only if EGL support is not available.
2021-05-10 17:11:05 +00:00
}
gl: Move vfunc Instead of Display::make_gl_context_current() we now have GLContext::clear_current() GLContext::make_current() This fits better with the backends (we can actually implement clearCurrent on macOS now) and makes it easier to implement different GL backends for backends (like EGL/GLX on X11). We also pass a surfaceless boolean to make_current() so the calling code can decide if a surface needs to be bound or not, because the backends were all doing whatever, which was very counterproductive.
2021-07-07 02:40:34 +00:00
static gboolean
gdk_x11_gl_context_egl_clear_current (GdkGLContext *context)
{
GdkDisplay *display = gdk_gl_context_get_display (context);
GdkX11Display *display_x11 = GDK_X11_DISPLAY (display);
return eglMakeCurrent (display_x11->egl_display,
EGL_NO_SURFACE,
EGL_NO_SURFACE,
EGL_NO_CONTEXT);
}
static gboolean
gdk_x11_gl_context_egl_make_current (GdkGLContext *context,
gboolean surfaceless)
{
x11: Move code from GdkGLContextX11 It's not used there, but both backends have independent immplementationgs for it. I want to get rid of GdkGLContextX11 and moving code from it is the first step.
2021-07-13 03:04:45 +00:00
GdkX11GLContextEGL *self = GDK_X11_GL_CONTEXT_EGL (context);
gl: Move vfunc Instead of Display::make_gl_context_current() we now have GLContext::clear_current() GLContext::make_current() This fits better with the backends (we can actually implement clearCurrent on macOS now) and makes it easier to implement different GL backends for backends (like EGL/GLX on X11). We also pass a surfaceless boolean to make_current() so the calling code can decide if a surface needs to be bound or not, because the backends were all doing whatever, which was very counterproductive.
2021-07-07 02:40:34 +00:00
GdkDisplay *display = gdk_gl_context_get_display (context);
GdkX11Display *display_x11 = GDK_X11_DISPLAY (display);
GdkSurface *surface;
EGLSurface egl_surface;
gboolean do_frame_sync = FALSE;
if (surfaceless)
{
return eglMakeCurrent (display_x11->egl_display,
EGL_NO_SURFACE,
EGL_NO_SURFACE,
x11: Move code from GdkGLContextX11 It's not used there, but both backends have independent immplementationgs for it. I want to get rid of GdkGLContextX11 and moving code from it is the first step.
2021-07-13 03:04:45 +00:00
self->egl_context);
gl: Move vfunc Instead of Display::make_gl_context_current() we now have GLContext::clear_current() GLContext::make_current() This fits better with the backends (we can actually implement clearCurrent on macOS now) and makes it easier to implement different GL backends for backends (like EGL/GLX on X11). We also pass a surfaceless boolean to make_current() so the calling code can decide if a surface needs to be bound or not, because the backends were all doing whatever, which was very counterproductive.
2021-07-07 02:40:34 +00:00
}
surface = gdk_gl_context_get_surface (context);
egl_surface = gdk_x11_surface_get_egl_surface (surface);
GDK_DISPLAY_NOTE (display, OPENGL,
g_message ("Making EGL context %p current to surface %p",
x11: Move code from GdkGLContextX11 It's not used there, but both backends have independent immplementationgs for it. I want to get rid of GdkGLContextX11 and moving code from it is the first step.
2021-07-13 03:04:45 +00:00
self->egl_context, egl_surface));
gl: Move vfunc Instead of Display::make_gl_context_current() we now have GLContext::clear_current() GLContext::make_current() This fits better with the backends (we can actually implement clearCurrent on macOS now) and makes it easier to implement different GL backends for backends (like EGL/GLX on X11). We also pass a surfaceless boolean to make_current() so the calling code can decide if a surface needs to be bound or not, because the backends were all doing whatever, which was very counterproductive.
2021-07-07 02:40:34 +00:00
if (!eglMakeCurrent (display_x11->egl_display,
egl_surface,
egl_surface,
x11: Move code from GdkGLContextX11 It's not used there, but both backends have independent immplementationgs for it. I want to get rid of GdkGLContextX11 and moving code from it is the first step.
2021-07-13 03:04:45 +00:00
self->egl_context))
gl: Move vfunc Instead of Display::make_gl_context_current() we now have GLContext::clear_current() GLContext::make_current() This fits better with the backends (we can actually implement clearCurrent on macOS now) and makes it easier to implement different GL backends for backends (like EGL/GLX on X11). We also pass a surfaceless boolean to make_current() so the calling code can decide if a surface needs to be bound or not, because the backends were all doing whatever, which was very counterproductive.
2021-07-07 02:40:34 +00:00
return FALSE;
/* If the WM is compositing there is no particular need to delay
* the swap when drawing on the offscreen, rendering to the screen
* happens later anyway, and its up to the compositor to sync that
* to the vblank. */
do_frame_sync = ! gdk_display_is_composited (display);
x11: Move code from GdkGLContextX11 It's not used there, but both backends have independent immplementationgs for it. I want to get rid of GdkGLContextX11 and moving code from it is the first step.
2021-07-13 03:04:45 +00:00
if (do_frame_sync != self->do_frame_sync)
gl: Move vfunc Instead of Display::make_gl_context_current() we now have GLContext::clear_current() GLContext::make_current() This fits better with the backends (we can actually implement clearCurrent on macOS now) and makes it easier to implement different GL backends for backends (like EGL/GLX on X11). We also pass a surfaceless boolean to make_current() so the calling code can decide if a surface needs to be bound or not, because the backends were all doing whatever, which was very counterproductive.
2021-07-07 02:40:34 +00:00
{
x11: Move code from GdkGLContextX11 It's not used there, but both backends have independent immplementationgs for it. I want to get rid of GdkGLContextX11 and moving code from it is the first step.
2021-07-13 03:04:45 +00:00
self->do_frame_sync = do_frame_sync;
gl: Move vfunc Instead of Display::make_gl_context_current() we now have GLContext::clear_current() GLContext::make_current() This fits better with the backends (we can actually implement clearCurrent on macOS now) and makes it easier to implement different GL backends for backends (like EGL/GLX on X11). We also pass a surfaceless boolean to make_current() so the calling code can decide if a surface needs to be bound or not, because the backends were all doing whatever, which was very counterproductive.
2021-07-07 02:40:34 +00:00
if (do_frame_sync)
eglSwapInterval (display_x11->egl_display, 1);
else
eglSwapInterval (display_x11->egl_display, 0);
}
return TRUE;
}
x11: Use EGL for GL support This makes the X11 backend similar to the Wayland one, when it comes to OpenGL. Fall back to GLX only if EGL support is not available.
2021-05-10 17:11:05 +00:00
static cairo_region_t *
gdk_x11_gl_context_egl_get_damage (GdkGLContext *context)
{
GdkDisplay *display = gdk_draw_context_get_display (GDK_DRAW_CONTEXT (context));
GdkX11Display *display_x11 = GDK_X11_DISPLAY (display);
if (display_x11->has_egl_buffer_age)
{
GdkSurface *surface = gdk_draw_context_get_surface (GDK_DRAW_CONTEXT (context));
EGLSurface egl_surface;
int buffer_age = 0;
x11: Store the EGL config in the display We only have one config, because we use the same Visual everywhere. Store this config in the GdkDisplayX11 struct for easy access. Also do this on initialize, because if creating the config fails, we want to switch to GLX instead of failing to do GL at all. This also simplifies a lot of code as we can share Visual, Colormap, etc across surfaces.
2021-06-09 11:42:19 +00:00
egl_surface = gdk_x11_surface_get_egl_surface (surface);
gdk: Get rid of paint contexts ... or more exactly: Only use paint contexts with gdk_cairo_draw_from_gl(). Instead of paint contexts being the only contexts who call swapBuffer(), any context can be used for this, when it's used with begin_frame()/end_frame(). This removes 2 features: 1. We no longer need a big sharing hierarchy. All contexts are now shared with gdk_display_get_gl_context(). 2. There is no longer a difference between attached and non-attached contexts. All contexts work the same way.
2021-07-06 02:50:01 +00:00
gdk_gl_context_make_current (context);
x11: Use EGL for GL support This makes the X11 backend similar to the Wayland one, when it comes to OpenGL. Fall back to GLX only if EGL support is not available.
2021-05-10 17:11:05 +00:00
x11: Move the EGL display into the private struct There's no need to use g_object_set_data() for it. We can also stop caching it elsewhere because we know the display has it. And finally, we can remove the display->have_egl boolean and use display->egl_display != NULL instead. We initialize the display at startup, so that variable is the perfect indicator.
2021-06-07 12:30:29 +00:00
eglQuerySurface (display_x11->egl_display,
x11: Use EGL for GL support This makes the X11 backend similar to the Wayland one, when it comes to OpenGL. Fall back to GLX only if EGL support is not available.
2021-05-10 17:11:05 +00:00
egl_surface,
EGL_BUFFER_AGE_EXT,
&buffer_age);
switch (buffer_age)
{
case 1:
return cairo_region_create ();
case 2:
if (context->old_updated_area[0])
return cairo_region_copy (context->old_updated_area[0]);
break;
case 3:
if (context->old_updated_area[0] && context->old_updated_area[1])
{
cairo_region_t *damage = cairo_region_copy (context->old_updated_area[0]);
cairo_region_union (damage, context->old_updated_area[1]);
return damage;
}
break;
default:
break;
}
}
return GDK_GL_CONTEXT_CLASS (gdk_x11_gl_context_egl_parent_class)->get_damage (context);
}
#define N_EGL_ATTRS 16
static gboolean
gdk_x11_gl_context_egl_realize (GdkGLContext *context,
GError **error)
{
GdkX11Display *display_x11;
GdkDisplay *display;
GdkX11GLContextEGL *context_egl;
gdk: Add GdkDisplay::init_gl vfunc The vfunc is called to initialize GL and it returns a "base" context that GDK then uses as the context all others are shared with. So the GL context share tree now looks like: + context from init_gl - context1 - context2 ... So this is a flat tree now, the complexity is gone. The only caveat is that backends now need to create a GL context when initializing GL so some refactoring was needed. Two new functions have been added: * gdk_display_prepare_gl() This is public API and can be used to ensure that GL has been initialized or if not, retrieve an error to display (or debug-print). * gdk_display_get_gl_context() This is a private function to retrieve the base context from init_gl(). It replaces gdk_surface_get_shared_data_context().
2021-07-04 23:57:03 +00:00
GdkGLContext *share;
x11: Use EGL for GL support This makes the X11 backend similar to the Wayland one, when it comes to OpenGL. Fall back to GLX only if EGL support is not available.
2021-05-10 17:11:05 +00:00
gboolean debug_bit, forward_bit, legacy_bit, use_es;
int major, minor, i = 0;
EGLint context_attrs[N_EGL_ATTRS];
gdk: Add GdkDisplay::init_gl vfunc The vfunc is called to initialize GL and it returns a "base" context that GDK then uses as the context all others are shared with. So the GL context share tree now looks like: + context from init_gl - context1 - context2 ... So this is a flat tree now, the complexity is gone. The only caveat is that backends now need to create a GL context when initializing GL so some refactoring was needed. Two new functions have been added: * gdk_display_prepare_gl() This is public API and can be used to ensure that GL has been initialized or if not, retrieve an error to display (or debug-print). * gdk_display_get_gl_context() This is a private function to retrieve the base context from init_gl(). It replaces gdk_surface_get_shared_data_context().
2021-07-04 23:57:03 +00:00
display = gdk_gl_context_get_display (context);
x11: Use EGL for GL support This makes the X11 backend similar to the Wayland one, when it comes to OpenGL. Fall back to GLX only if EGL support is not available.
2021-05-10 17:11:05 +00:00
context_egl = GDK_X11_GL_CONTEXT_EGL (context);
display_x11 = GDK_X11_DISPLAY (display);
gdk: Add GdkDisplay::init_gl vfunc The vfunc is called to initialize GL and it returns a "base" context that GDK then uses as the context all others are shared with. So the GL context share tree now looks like: + context from init_gl - context1 - context2 ... So this is a flat tree now, the complexity is gone. The only caveat is that backends now need to create a GL context when initializing GL so some refactoring was needed. Two new functions have been added: * gdk_display_prepare_gl() This is public API and can be used to ensure that GL has been initialized or if not, retrieve an error to display (or debug-print). * gdk_display_get_gl_context() This is a private function to retrieve the base context from init_gl(). It replaces gdk_surface_get_shared_data_context().
2021-07-04 23:57:03 +00:00
share = gdk_display_get_gl_context (display);
x11: Use EGL for GL support This makes the X11 backend similar to the Wayland one, when it comes to OpenGL. Fall back to GLX only if EGL support is not available.
2021-05-10 17:11:05 +00:00
gdk_gl_context_get_required_version (context, &major, &minor);
debug_bit = gdk_gl_context_get_debug_enabled (context);
forward_bit = gdk_gl_context_get_forward_compatible (context);
legacy_bit = GDK_DISPLAY_DEBUG_CHECK (display, GL_LEGACY) ||
(share != NULL && gdk_gl_context_is_legacy (share));
use_es = GDK_DISPLAY_DEBUG_CHECK (display, GL_GLES) ||
(share != NULL && gdk_gl_context_get_use_es (share));
if (!use_es)
{
eglBindAPI (EGL_OPENGL_API);
if (display_x11->has_egl_khr_create_context)
{
int flags = 0;
if (debug_bit)
flags |= EGL_CONTEXT_OPENGL_DEBUG_BIT_KHR;
if (forward_bit)
flags |= EGL_CONTEXT_OPENGL_FORWARD_COMPATIBLE_BIT_KHR;
context_attrs[i++] = EGL_CONTEXT_OPENGL_PROFILE_MASK_KHR;
context_attrs[i++] = legacy_bit
? EGL_CONTEXT_OPENGL_COMPATIBILITY_PROFILE_BIT_KHR
: EGL_CONTEXT_OPENGL_CORE_PROFILE_BIT_KHR;
context_attrs[i++] = EGL_CONTEXT_MAJOR_VERSION_KHR;
context_attrs[i++] = legacy_bit ? 3 : major;
context_attrs[i++] = EGL_CONTEXT_MINOR_VERSION_KHR;
context_attrs[i++] = legacy_bit ? 0 : minor;
context_attrs[i++] = EGL_CONTEXT_FLAGS_KHR;
context_attrs[i++] = flags;
context_attrs[i++] = EGL_NONE;
}
else
{
context_attrs[i++] = EGL_NONE;
}
}
else
{
eglBindAPI (EGL_OPENGL_ES_API);
context_attrs[i++] = EGL_CONTEXT_CLIENT_VERSION;
if (major == 3)
context_attrs[i++] = 3;
else
context_attrs[i++] = 2;
}
context_attrs[i++] = EGL_NONE;
g_assert (i < N_EGL_ATTRS);
GDK_DISPLAY_NOTE (display, OPENGL,
g_message ("Creating EGL context version %d.%d (shared:%s, debug:%s, forward:%s, legacy:%s, es:%s)",
major, minor,
share != NULL ? "yes" : "no",
debug_bit ? "yes" : "no",
forward_bit ? "yes" : "no",
legacy_bit ? "yes" : "no",
use_es ? "yes" : "no"));
context_egl->egl_context =
x11: Move the EGL display into the private struct There's no need to use g_object_set_data() for it. We can also stop caching it elsewhere because we know the display has it. And finally, we can remove the display->have_egl boolean and use display->egl_display != NULL instead. We initialize the display at startup, so that variable is the perfect indicator.
2021-06-07 12:30:29 +00:00
eglCreateContext (display_x11->egl_display,
x11: Store the EGL config in the display We only have one config, because we use the same Visual everywhere. Store this config in the GdkDisplayX11 struct for easy access. Also do this on initialize, because if creating the config fails, we want to switch to GLX instead of failing to do GL at all. This also simplifies a lot of code as we can share Visual, Colormap, etc across surfaces.
2021-06-09 11:42:19 +00:00
display_x11->egl_config,
x11: Use EGL for GL support This makes the X11 backend similar to the Wayland one, when it comes to OpenGL. Fall back to GLX only if EGL support is not available.
2021-05-10 17:11:05 +00:00
share != NULL
? GDK_X11_GL_CONTEXT_EGL (share)->egl_context
gdk: Add GdkDisplay::init_gl vfunc The vfunc is called to initialize GL and it returns a "base" context that GDK then uses as the context all others are shared with. So the GL context share tree now looks like: + context from init_gl - context1 - context2 ... So this is a flat tree now, the complexity is gone. The only caveat is that backends now need to create a GL context when initializing GL so some refactoring was needed. Two new functions have been added: * gdk_display_prepare_gl() This is public API and can be used to ensure that GL has been initialized or if not, retrieve an error to display (or debug-print). * gdk_display_get_gl_context() This is a private function to retrieve the base context from init_gl(). It replaces gdk_surface_get_shared_data_context().
2021-07-04 23:57:03 +00:00
: EGL_NO_CONTEXT,
x11: Use EGL for GL support This makes the X11 backend similar to the Wayland one, when it comes to OpenGL. Fall back to GLX only if EGL support is not available.
2021-05-10 17:11:05 +00:00
context_attrs);
/* If we're not asking for a GLES context, and we don't have the legacy bit set
* already, try again with a legacy context
*/
if (context_egl->egl_context == NULL && !use_es && !legacy_bit)
{
context_attrs[1] = EGL_CONTEXT_OPENGL_COMPATIBILITY_PROFILE_BIT_KHR;
context_attrs[3] = 3;
context_attrs[5] = 0;
legacy_bit = TRUE;
use_es = FALSE;
GDK_NOTE (OPENGL,
g_message ("Context creation failed; trying legacy EGL context"));
context_egl->egl_context =
x11: Move the EGL display into the private struct There's no need to use g_object_set_data() for it. We can also stop caching it elsewhere because we know the display has it. And finally, we can remove the display->have_egl boolean and use display->egl_display != NULL instead. We initialize the display at startup, so that variable is the perfect indicator.
2021-06-07 12:30:29 +00:00
eglCreateContext (display_x11->egl_display,
x11: Store the EGL config in the display We only have one config, because we use the same Visual everywhere. Store this config in the GdkDisplayX11 struct for easy access. Also do this on initialize, because if creating the config fails, we want to switch to GLX instead of failing to do GL at all. This also simplifies a lot of code as we can share Visual, Colormap, etc across surfaces.
2021-06-09 11:42:19 +00:00
display_x11->egl_config,
x11: Use EGL for GL support This makes the X11 backend similar to the Wayland one, when it comes to OpenGL. Fall back to GLX only if EGL support is not available.
2021-05-10 17:11:05 +00:00
share != NULL
? GDK_X11_GL_CONTEXT_EGL (share)->egl_context
gdk: Add GdkDisplay::init_gl vfunc The vfunc is called to initialize GL and it returns a "base" context that GDK then uses as the context all others are shared with. So the GL context share tree now looks like: + context from init_gl - context1 - context2 ... So this is a flat tree now, the complexity is gone. The only caveat is that backends now need to create a GL context when initializing GL so some refactoring was needed. Two new functions have been added: * gdk_display_prepare_gl() This is public API and can be used to ensure that GL has been initialized or if not, retrieve an error to display (or debug-print). * gdk_display_get_gl_context() This is a private function to retrieve the base context from init_gl(). It replaces gdk_surface_get_shared_data_context().
2021-07-04 23:57:03 +00:00
: EGL_NO_CONTEXT,
x11: Use EGL for GL support This makes the X11 backend similar to the Wayland one, when it comes to OpenGL. Fall back to GLX only if EGL support is not available.
2021-05-10 17:11:05 +00:00
context_attrs);
}
if (context_egl->egl_context == NULL)
{
g_set_error_literal (error, GDK_GL_ERROR, GDK_GL_ERROR_NOT_AVAILABLE,
_("Unable to create a GL context"));
return FALSE;
}
gdk_gl_context_set_is_legacy (context, legacy_bit);
gdk_gl_context_set_use_es (context, use_es);
GDK_NOTE (OPENGL,
g_message ("Realized EGL context[%p]",
context_egl->egl_context));
return TRUE;
}
#undef N_EGL_ATTRS
static void
gdk_x11_gl_context_egl_dispose (GObject *gobject)
{
GdkX11GLContextEGL *context_egl = GDK_X11_GL_CONTEXT_EGL (gobject);
if (context_egl->egl_context != NULL)
{
GdkGLContext *context = GDK_GL_CONTEXT (gobject);
x11: Move the EGL display into the private struct There's no need to use g_object_set_data() for it. We can also stop caching it elsewhere because we know the display has it. And finally, we can remove the display->have_egl boolean and use display->egl_display != NULL instead. We initialize the display at startup, so that variable is the perfect indicator.
2021-06-07 12:30:29 +00:00
GdkX11Display *display_x11 = GDK_X11_DISPLAY (gdk_gl_context_get_display (context));
x11: Use EGL for GL support This makes the X11 backend similar to the Wayland one, when it comes to OpenGL. Fall back to GLX only if EGL support is not available.
2021-05-10 17:11:05 +00:00
/* Unset the current context if we're disposing it */
if (eglGetCurrentContext () == context_egl->egl_context)
x11: Move the EGL display into the private struct There's no need to use g_object_set_data() for it. We can also stop caching it elsewhere because we know the display has it. And finally, we can remove the display->have_egl boolean and use display->egl_display != NULL instead. We initialize the display at startup, so that variable is the perfect indicator.
2021-06-07 12:30:29 +00:00
eglMakeCurrent (display_x11->egl_display, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT);
x11: Use EGL for GL support This makes the X11 backend similar to the Wayland one, when it comes to OpenGL. Fall back to GLX only if EGL support is not available.
2021-05-10 17:11:05 +00:00
GDK_NOTE (OPENGL, g_message ("Destroying EGL context"));
x11: Move the EGL display into the private struct There's no need to use g_object_set_data() for it. We can also stop caching it elsewhere because we know the display has it. And finally, we can remove the display->have_egl boolean and use display->egl_display != NULL instead. We initialize the display at startup, so that variable is the perfect indicator.
2021-06-07 12:30:29 +00:00
eglDestroyContext (display_x11->egl_display, context_egl->egl_context);
x11: Use EGL for GL support This makes the X11 backend similar to the Wayland one, when it comes to OpenGL. Fall back to GLX only if EGL support is not available.
2021-05-10 17:11:05 +00:00
context_egl->egl_context = NULL;
}
G_OBJECT_CLASS (gdk_x11_gl_context_egl_parent_class)->dispose (gobject);
}
static void
gdk_x11_gl_context_egl_class_init (GdkX11GLContextEGLClass *klass)
{
GdkGLContextClass *context_class = GDK_GL_CONTEXT_CLASS (klass);
GdkDrawContextClass *draw_context_class = GDK_DRAW_CONTEXT_CLASS (klass);
GObjectClass *gobject_class = G_OBJECT_CLASS (klass);
gdk: Make sure only one GL backend is used Creative people managed to create an X11 display and a Wayland display at once, thereby getting EGL and GLX involved in a fight to the death over the ownership of the glFoo() symbolspace. A way to force such a fight with available tools here is (on Wayland) running something like: GTK_INSPECTOR_DISPLAY=:1 GTK_DEBUG=interactive gtk4-demo Related: xdg-desktop-portal-gnome#5
2021-09-23 23:47:03 +00:00
context_class->backend_type = GDK_GL_EGL;
x11: Use EGL for GL support This makes the X11 backend similar to the Wayland one, when it comes to OpenGL. Fall back to GLX only if EGL support is not available.
2021-05-10 17:11:05 +00:00
context_class->realize = gdk_x11_gl_context_egl_realize;
gl: Move vfunc Instead of Display::make_gl_context_current() we now have GLContext::clear_current() GLContext::make_current() This fits better with the backends (we can actually implement clearCurrent on macOS now) and makes it easier to implement different GL backends for backends (like EGL/GLX on X11). We also pass a surfaceless boolean to make_current() so the calling code can decide if a surface needs to be bound or not, because the backends were all doing whatever, which was very counterproductive.
2021-07-07 02:40:34 +00:00
context_class->make_current = gdk_x11_gl_context_egl_make_current;
context_class->clear_current = gdk_x11_gl_context_egl_clear_current;
x11: Use EGL for GL support This makes the X11 backend similar to the Wayland one, when it comes to OpenGL. Fall back to GLX only if EGL support is not available.
2021-05-10 17:11:05 +00:00
context_class->get_damage = gdk_x11_gl_context_egl_get_damage;
gl: Fix issue with EGL + nvidia nvidia sets the default draw buffer to GL_NONE if EGL contexts are initially bound to EGL_NO_SURFACE which is exactly what we are doing. So bind them to GL_BACK when drawing, as they should be. See https://phabricator.services.mozilla.com/D118743 for a discussion about EGL_NO_CONTEXT and draw buffers.
2021-07-10 00:29:17 +00:00
draw_context_class->begin_frame = gdk_x11_gl_context_egl_begin_frame;
x11: Use EGL for GL support This makes the X11 backend similar to the Wayland one, when it comes to OpenGL. Fall back to GLX only if EGL support is not available.
2021-05-10 17:11:05 +00:00
draw_context_class->end_frame = gdk_x11_gl_context_egl_end_frame;
gobject_class->dispose = gdk_x11_gl_context_egl_dispose;
}
static void
gdk_x11_gl_context_egl_init (GdkX11GLContextEGL *self)
{
x11: Move code from GdkGLContextX11 It's not used there, but both backends have independent immplementationgs for it. I want to get rid of GdkGLContextX11 and moving code from it is the first step.
2021-07-13 03:04:45 +00:00
self->do_frame_sync = TRUE;
x11: Use EGL for GL support This makes the X11 backend similar to the Wayland one, when it comes to OpenGL. Fall back to GLX only if EGL support is not available.
2021-05-10 17:11:05 +00:00
}
x11: Better debug for egl Print the extensions one per line, and sort them alphabetically, so it is actually possible to find something in the list. Also print a short description of the chosen config.
2021-10-02 01:14:35 +00:00
#ifdef G_ENABLE_DEBUG
static int
strvcmp (gconstpointer p1,
gconstpointer p2)
{
const char * const *s1 = p1;
const char * const *s2 = p2;
return strcmp (*s1, *s2);
}
static char *
describe_extensions (EGLDisplay dpy)
{
const char *extensions;
char **exts;
char *ext;
extensions = eglQueryString (dpy, EGL_EXTENSIONS);
exts = g_strsplit (extensions, " ", -1);
qsort (exts, g_strv_length (exts), sizeof (char *), strvcmp);
ext = g_strjoinv ("\n\t", exts);
if (ext[0] == '\n')
ext[0] = ' ';
g_strfreev (exts);
return g_strstrip (ext);
}
static char *
describe_egl_config (EGLDisplay dpy,
EGLConfig config)
{
EGLint red, green, blue, alpha, type;
if (!config)
return g_strdup ("-");
if (!eglGetConfigAttrib (dpy, config, EGL_RED_SIZE, &red) ||
!eglGetConfigAttrib (dpy, config, EGL_GREEN_SIZE, &green) ||
!eglGetConfigAttrib (dpy, config, EGL_BLUE_SIZE, &blue) ||
!eglGetConfigAttrib (dpy, config, EGL_ALPHA_SIZE, &alpha))
return g_strdup ("Unknown");
if (epoxy_has_egl_extension (dpy, "EGL_EXT_pixel_format_float"))
{
if (!eglGetConfigAttrib (dpy, config, EGL_COLOR_COMPONENT_TYPE_EXT, &type))
type = EGL_COLOR_COMPONENT_TYPE_FIXED_EXT;
}
else
type = EGL_COLOR_COMPONENT_TYPE_FIXED_EXT;
return g_strdup_printf ("R%dG%dB%dA%d%s", red, green, blue, alpha, type == EGL_COLOR_COMPONENT_TYPE_FIXED_EXT ? "" : " float");
}
#endif
x11: Use EGL for GL support This makes the X11 backend similar to the Wayland one, when it comes to OpenGL. Fall back to GLX only if EGL support is not available.
2021-05-10 17:11:05 +00:00
gboolean
x11: Rework Visual selection Instead of going via GdkVisual, doing a preselection and letting the GL initialization improve it, let the GL initialization pick an X Visual directly using X Visual code directly. The code should select the same visuals as before as it tries to apply the same logic, but it's a rewrite, so I expect I messed something up.
2021-06-13 15:34:55 +00:00
gdk_x11_display_init_egl (GdkX11Display *self,
x11: Redo choice between EGL and GLX We try EGL first, but are very picky about what we accept. If that fails, we try to go with GLX instead. And if that also fails, we try EGL again, but this time accept anything. The idea here is that EGL is the preferred method going forward, but GLX is the tried and tested method that we know works. So if we detect issues with EGL, we want to avoid using it in favor of GLX. Also add a GDK_DEBUG=gl-egl option to force EGL at all costs and not try GLX.
2021-07-02 01:37:32 +00:00
gboolean force,
x11: Rework Visual selection Instead of going via GdkVisual, doing a preselection and letting the GL initialization improve it, let the GL initialization pick an X Visual directly using X Visual code directly. The code should select the same visuals as before as it tries to apply the same logic, but it's a rewrite, so I expect I messed something up.
2021-06-13 15:34:55 +00:00
Visual **out_visual,
x11: Properly record the error when initializing GL That way, we can give a useful error message when things break down for users. These error messages could still be improved in places (like looking at the actual EGL error codes), but that seemed overkill.
2021-07-02 01:21:14 +00:00
int *out_depth,
GError **error)
x11: Use EGL for GL support This makes the X11 backend similar to the Wayland one, when it comes to OpenGL. Fall back to GLX only if EGL support is not available.
2021-05-10 17:11:05 +00:00
{
x11: Move the EGL display into the private struct There's no need to use g_object_set_data() for it. We can also stop caching it elsewhere because we know the display has it. And finally, we can remove the display->have_egl boolean and use display->egl_display != NULL instead. We initialize the display at startup, so that variable is the perfect indicator.
2021-06-07 12:30:29 +00:00
GdkDisplay *display = GDK_DISPLAY (self);
x11: Use EGL for GL support This makes the X11 backend similar to the Wayland one, when it comes to OpenGL. Fall back to GLX only if EGL support is not available.
2021-05-10 17:11:05 +00:00
Display *dpy;
int major, minor;
gdk: Make sure only one GL backend is used Creative people managed to create an X11 display and a Wayland display at once, thereby getting EGL and GLX involved in a fight to the death over the ownership of the glFoo() symbolspace. A way to force such a fight with available tools here is (on Wayland) running something like: GTK_INSPECTOR_DISPLAY=:1 GTK_DEBUG=interactive gtk4-demo Related: xdg-desktop-portal-gnome#5
2021-09-23 23:47:03 +00:00
if (!gdk_gl_backend_can_be_used (GDK_GL_EGL, error))
return FALSE;
x11: Use EGL for GL support This makes the X11 backend similar to the Wayland one, when it comes to OpenGL. Fall back to GLX only if EGL support is not available.
2021-05-10 17:11:05 +00:00
dpy = gdk_x11_display_get_xdisplay (display);
if (!epoxy_has_egl ())
x11: Properly record the error when initializing GL That way, we can give a useful error message when things break down for users. These error messages could still be improved in places (like looking at the actual EGL error codes), but that seemed overkill.
2021-07-02 01:21:14 +00:00
{
g_set_error_literal (error, GDK_GL_ERROR,
GDK_GL_ERROR_NOT_AVAILABLE,
_("EGL is not supported"));
return FALSE;
}
x11: Use EGL for GL support This makes the X11 backend similar to the Wayland one, when it comes to OpenGL. Fall back to GLX only if EGL support is not available.
2021-05-10 17:11:05 +00:00
x11: Move the EGL display into the private struct There's no need to use g_object_set_data() for it. We can also stop caching it elsewhere because we know the display has it. And finally, we can remove the display->have_egl boolean and use display->egl_display != NULL instead. We initialize the display at startup, so that variable is the perfect indicator.
2021-06-07 12:30:29 +00:00
gdk_x11_display_create_egl_display (self);
if (self->egl_display == NULL)
x11: Properly record the error when initializing GL That way, we can give a useful error message when things break down for users. These error messages could still be improved in places (like looking at the actual EGL error codes), but that seemed overkill.
2021-07-02 01:21:14 +00:00
{
g_set_error_literal (error, GDK_GL_ERROR,
GDK_GL_ERROR_NOT_AVAILABLE,
_("Failed to create EGL display"));
return FALSE;
}
x11: Use EGL for GL support This makes the X11 backend similar to the Wayland one, when it comes to OpenGL. Fall back to GLX only if EGL support is not available.
2021-05-10 17:11:05 +00:00
x11: Move the EGL display into the private struct There's no need to use g_object_set_data() for it. We can also stop caching it elsewhere because we know the display has it. And finally, we can remove the display->have_egl boolean and use display->egl_display != NULL instead. We initialize the display at startup, so that variable is the perfect indicator.
2021-06-07 12:30:29 +00:00
if (!eglInitialize (self->egl_display, &major, &minor))
{
self->egl_display = NULL;
x11: Properly record the error when initializing GL That way, we can give a useful error message when things break down for users. These error messages could still be improved in places (like looking at the actual EGL error codes), but that seemed overkill.
2021-07-02 01:21:14 +00:00
g_set_error_literal (error, GDK_GL_ERROR,
GDK_GL_ERROR_NOT_AVAILABLE,
_("Could not initialize EGL display"));
x11: Move the EGL display into the private struct There's no need to use g_object_set_data() for it. We can also stop caching it elsewhere because we know the display has it. And finally, we can remove the display->have_egl boolean and use display->egl_display != NULL instead. We initialize the display at startup, so that variable is the perfect indicator.
2021-06-07 12:30:29 +00:00
return FALSE;
}
gdk: Require EGL version 1.4 across the board Mesa currently ships 1.5.
2021-07-05 01:04:08 +00:00
if (major < GDK_EGL_MIN_VERSION_MAJOR ||
(major == GDK_EGL_MIN_VERSION_MAJOR && minor < GDK_EGL_MIN_VERSION_MINOR))
{
eglTerminate (dpy);
self->egl_display = NULL;
g_set_error (error, GDK_GL_ERROR,
GDK_GL_ERROR_NOT_AVAILABLE,
_("EGL version %d.%d is too old. GTK requires %d.%d"),
major, minor, GDK_EGL_MIN_VERSION_MAJOR, GDK_EGL_MIN_VERSION_MINOR);
return FALSE;
}
x11: Use EGL for GL support This makes the X11 backend similar to the Wayland one, when it comes to OpenGL. Fall back to GLX only if EGL support is not available.
2021-05-10 17:11:05 +00:00
gl: Require EGL_KHR_surfaceless_context with egl The code to create and manage a fake egl surface to bind to is complex and completely untested because everyone seems to support this extension. nvidia and Mesa do support it and according to Mesa devs, adding support in a new driver is rather simple and Mesa drivers gain that feature automatically, so all future drivers shoould have it.
2021-07-07 01:00:09 +00:00
if (!epoxy_has_egl_extension (self->egl_display, "EGL_KHR_surfaceless_context"))
{
eglTerminate (dpy);
self->egl_display = NULL;
g_set_error_literal (error, GDK_GL_ERROR,
GDK_GL_ERROR_UNSUPPORTED_PROFILE,
_("Surfaceless contexts are not supported on this EGL implementation"));
return FALSE;
}
x11: Redo choice between EGL and GLX We try EGL first, but are very picky about what we accept. If that fails, we try to go with GLX instead. And if that also fails, we try EGL again, but this time accept anything. The idea here is that EGL is the preferred method going forward, but GLX is the tried and tested method that we know works. So if we detect issues with EGL, we want to avoid using it in favor of GLX. Also add a GDK_DEBUG=gl-egl option to force EGL at all costs and not try GLX.
2021-07-02 01:37:32 +00:00
if (!gdk_x11_display_create_egl_config (self, force, out_visual, out_depth, error))
x11: Store the EGL config in the display We only have one config, because we use the same Visual everywhere. Store this config in the GdkDisplayX11 struct for easy access. Also do this on initialize, because if creating the config fails, we want to switch to GLX instead of failing to do GL at all. This also simplifies a lot of code as we can share Visual, Colormap, etc across surfaces.
2021-06-09 11:42:19 +00:00
{
eglTerminate (self->egl_display);
self->egl_display = NULL;
return FALSE;
}
x11: Move the EGL display into the private struct There's no need to use g_object_set_data() for it. We can also stop caching it elsewhere because we know the display has it. And finally, we can remove the display->have_egl boolean and use display->egl_display != NULL instead. We initialize the display at startup, so that variable is the perfect indicator.
2021-06-07 12:30:29 +00:00
self->egl_version = epoxy_egl_version (dpy);
x11: Use EGL for GL support This makes the X11 backend similar to the Wayland one, when it comes to OpenGL. Fall back to GLX only if EGL support is not available.
2021-05-10 17:11:05 +00:00
x11: Move the EGL display into the private struct There's no need to use g_object_set_data() for it. We can also stop caching it elsewhere because we know the display has it. And finally, we can remove the display->have_egl boolean and use display->egl_display != NULL instead. We initialize the display at startup, so that variable is the perfect indicator.
2021-06-07 12:30:29 +00:00
self->has_egl_khr_create_context =
epoxy_has_egl_extension (self->egl_display, "EGL_KHR_create_context");
self->has_egl_buffer_age =
epoxy_has_egl_extension (self->egl_display, "EGL_EXT_buffer_age");
self->has_egl_swap_buffers_with_damage =
epoxy_has_egl_extension (self->egl_display, "EGL_EXT_swap_buffers_with_damage");
x11: Use EGL for GL support This makes the X11 backend similar to the Wayland one, when it comes to OpenGL. Fall back to GLX only if EGL support is not available.
2021-05-10 17:11:05 +00:00
x11: Better debug for egl Print the extensions one per line, and sort them alphabetically, so it is actually possible to find something in the list. Also print a short description of the chosen config.
2021-10-02 01:14:35 +00:00
GDK_DISPLAY_NOTE (display, OPENGL, {
char *ext = describe_extensions (self->egl_display);
char *cfg = describe_egl_config (self->egl_display, self->egl_config);
x11: Use EGL for GL support This makes the X11 backend similar to the Wayland one, when it comes to OpenGL. Fall back to GLX only if EGL support is not available.
2021-05-10 17:11:05 +00:00
g_message ("EGL found\n"
" - Version: %s\n"
" - Vendor: %s\n"
" - Client API: %s\n"
x11: Better debug for egl Print the extensions one per line, and sort them alphabetically, so it is actually possible to find something in the list. Also print a short description of the chosen config.
2021-10-02 01:14:35 +00:00
" - Extensions:\n"
"\t%s\n"
" - Config: %s",
x11: Move the EGL display into the private struct There's no need to use g_object_set_data() for it. We can also stop caching it elsewhere because we know the display has it. And finally, we can remove the display->have_egl boolean and use display->egl_display != NULL instead. We initialize the display at startup, so that variable is the perfect indicator.
2021-06-07 12:30:29 +00:00
eglQueryString (self->egl_display, EGL_VERSION),
eglQueryString (self->egl_display, EGL_VENDOR),
eglQueryString (self->egl_display, EGL_CLIENT_APIS),
x11: Better debug for egl Print the extensions one per line, and sort them alphabetically, so it is actually possible to find something in the list. Also print a short description of the chosen config.
2021-10-02 01:14:35 +00:00
ext, cfg);
g_free (ext);
g_free (cfg);
});
x11: Use EGL for GL support This makes the X11 backend similar to the Wayland one, when it comes to OpenGL. Fall back to GLX only if EGL support is not available.
2021-05-10 17:11:05 +00:00
return TRUE;
}
/**
* gdk_x11_display_get_egl_version:
gdk: Clean up docs syntax Replace leftover gtk-doc syntax (#Type) with backquotes.
2021-05-20 03:39:18 +00:00
* @display: (type GdkX11Display): a `GdkDisplay`
x11: Use EGL for GL support This makes the X11 backend similar to the Wayland one, when it comes to OpenGL. Fall back to GLX only if EGL support is not available.
2021-05-10 17:11:05 +00:00
* @major: (out): return location for the EGL major version
* @minor: (out): return location for the EGL minor version
*
* Retrieves the version of the EGL implementation.
*
* Returns: %TRUE if EGL is available
*
* Since: 4.4
*/
gboolean
gdk_x11_display_get_egl_version (GdkDisplay *display,
int *major,
int *minor)
{
g_return_val_if_fail (GDK_IS_DISPLAY (display), FALSE);
if (!GDK_IS_X11_DISPLAY (display))
return FALSE;
GdkX11Display *display_x11 = GDK_X11_DISPLAY (display);
x11: Move the EGL display into the private struct There's no need to use g_object_set_data() for it. We can also stop caching it elsewhere because we know the display has it. And finally, we can remove the display->have_egl boolean and use display->egl_display != NULL instead. We initialize the display at startup, so that variable is the perfect indicator.
2021-06-07 12:30:29 +00:00
if (display_x11->egl_display == NULL)
x11: Use EGL for GL support This makes the X11 backend similar to the Wayland one, when it comes to OpenGL. Fall back to GLX only if EGL support is not available.
2021-05-10 17:11:05 +00:00
return FALSE;
if (major != NULL)
*major = display_x11->egl_version / 10;
if (minor != NULL)
*minor = display_x11->egl_version % 10;
return TRUE;
}
Reference in New Issue Copy Permalink