AuroraMiddleware/gtk
1
0
Fork 1
mirror of https://gitlab.gnome.org/GNOME/gtk.git synced 2024-12-28 22:41:43 +00:00
Code Issues Projects Releases Wiki Activity
cfaf1b3e71
gtk/gdk/wayland/gdkglcontext-wayland.c

136 lines
4.0 KiB
C
Raw Normal View History

wayland: Add OpenGL support This uses EGL to implement GdkGLContext for wayland.
2014-10-09 09:06:48 +00:00
/* GDK - The GIMP Drawing Kit
*
* gdkglcontext-wayland.c: Wayland specific OpenGL wrappers
*
* Copyright © 2014 Emmanuele Bassi
* Copyright © 2014 Alexander Larsson
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Library General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Library General Public License for more details.
*
* You should have received a copy of the GNU Library General Public
* License along with this library. If not, see <http://www.gnu.org/licenses/>.
*/
#include "config.h"
#include "gdkglcontext-wayland.h"
wayland: Don't pass GL config to get_egl_surface() There's only one GL config.
2021-07-04 18:55:53 +00:00
wayland: Add OpenGL support This uses EGL to implement GdkGLContext for wayland.
2014-10-09 09:06:48 +00:00
#include "gdkdisplay-wayland.h"
wayland: Don't pass GL config to get_egl_surface() There's only one GL config.
2021-07-04 18:55:53 +00:00
#include "gdksurface-wayland.h"
Make mask nodes more versatile Add a GskMaskMode enumeration and implement it in the GL and cairo renderers.
2023-02-14 18:44:39 +00:00
#include "gdksurface-wayland-private.h"
wayland: Add OpenGL support This uses EGL to implement GdkGLContext for wayland.
2014-10-09 09:06:48 +00:00
#include "gdkwaylanddisplay.h"
#include "gdkwaylandglcontext.h"
GdkWindow -> GdkSurface: File renames Rename all *window.[ch] source files. This is an automatic operation, done by the following commands: for i in $(git ls-files gdk | grep window); do git mv $i $(echo $i | sed s/window/surface/); git sed -f g $(basename $i) $(basename $i | sed s/window/surface/) ; done git checkout NEWS* po-properties po
2018-03-20 10:46:11 +00:00
#include "gdkwaylandsurface.h"
wayland: Add OpenGL support This uses EGL to implement GdkGLContext for wayland.
2014-10-09 09:06:48 +00:00
#include "gdkprivate-wayland.h"
Rename gdk-private.h to gdkprivate.h The extra - does not add any value.
2022-09-24 03:23:27 +00:00
#include "gdkprivate.h"
Get rid of GdkSurfaceImpl We don't need the complicated wrapper system anymore, since client-side windows are gone. This commit moves all the vfuncs to GtkSurfaceClass, and changes the backends to just derive their surface implementation from GdkSurface.
2019-04-22 01:14:46 +00:00
#include "gdksurfaceprivate.h"
wayland: Add profiler marks around surface handling Add marks for when we do commits, swap buffer or receive frame events. These are the low-level start and end points of the frame cycle, and it is useful to see them in the profiler.
2020-01-22 19:51:40 +00:00
#include "gdkprofilerprivate.h"
wayland: Add OpenGL support This uses EGL to implement GdkGLContext for wayland.
2014-10-09 09:06:48 +00:00
Drop gdkintl.h This header was merely including gi18n-lib.h. Just do that directly.
2022-09-24 03:33:42 +00:00
#include <glib/gi18n-lib.h>
wayland: Add OpenGL support This uses EGL to implement GdkGLContext for wayland.
2014-10-09 09:06:48 +00:00
docs: Brush up the Wayland backend docs Add some content here.
2021-02-21 15:40:24 +00:00
/**
* GdkWaylandGLContext:
*
* The Wayland implementation of `GdkGLContext`.
*/
wayland: Add OpenGL support This uses EGL to implement GdkGLContext for wayland.
2014-10-09 09:06:48 +00:00
G_DEFINE_TYPE (GdkWaylandGLContext, gdk_wayland_gl_context, GDK_TYPE_GL_CONTEXT)
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_wayland_gl_context_begin_frame (GdkDrawContext *draw_context,
gdk: hdr => high depth The term "hdr" is so overloaded, we shouldn't use them anywhere, except from maybe describing all of this work in blog posts and other marketing materials. So do renames: * hdr => high_depth * request_hdr => prefers_high_depth This more accurately describes what is going on.
2021-10-06 16:25:30 +00:00
gboolean prefers_high_depth,
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
cairo_region_t *region)
{
egl: Move EGLSurface handling to GdkSurface Calling gdk_surface_set_egl_native_window() enables this.
2021-10-03 19:58:57 +00:00
gdk_wayland_surface_ensure_wl_egl_window (gdk_draw_context_get_surface (draw_context));
gdk: hdr => high depth The term "hdr" is so overloaded, we shouldn't use them anywhere, except from maybe describing all of this work in blog posts and other marketing materials. So do renames: * hdr => high_depth * request_hdr => prefers_high_depth This more accurately describes what is going on.
2021-10-06 16:25:30 +00:00
GDK_DRAW_CONTEXT_CLASS (gdk_wayland_gl_context_parent_class)->begin_frame (draw_context, prefers_high_depth, region);
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
}
wayland: Add OpenGL support This uses EGL to implement GdkGLContext for wayland.
2014-10-09 09:06:48 +00:00
static void
gdk: Make gdk_window_begin_draw_frame() take a draw context ... instead of a gl context. This requires some refactoring in the way we mark the shared context as drawing: We now call begin_frame/end_frame() on it and ignore the call on the main context. Unfortunately we need to do this check in all vfuncs, which sucks. But I haven't found a better way.
2016-12-01 00:38:20 +00:00
gdk_wayland_gl_context_end_frame (GdkDrawContext *draw_context,
drawcontext: Only pass the region that matters We used to pass 2 regions to GdkDrawCotnext.end_frame() but code was confusing what they meant. So we now don't do that anymore and only pass the region that matters: The frame region.
2018-04-23 21:26:14 +00:00
cairo_region_t *painted)
wayland: Add OpenGL support This uses EGL to implement GdkGLContext for wayland.
2014-10-09 09:06:48 +00:00
{
egl: Unify contexts Unify the X11 and Wayland EGL contexts. This is a bit ugly to implement, because I don't want to create an interface and I can't make them inherit from the same object, because one needs to inherit from X11GLContext and the other from WaylandGLContext. So we have to put the code in GdkGLContext and make sure non-EGL contexts can't accidentally run it. This is rather easy because we can just check for priv->egl_context != NULL.
2021-10-05 22:34:10 +00:00
GdkSurface *surface = gdk_draw_context_get_surface (draw_context);
Make mask nodes more versatile Add a GskMaskMode enumeration and implement it in the GL and cairo renderers.
2023-02-14 18:44:39 +00:00
GdkWaylandSurface *impl = GDK_WAYLAND_SURFACE (surface);
int dx = impl->pending_buffer_offset_x;
int dy = impl->pending_buffer_offset_y;
gdk: Make gdk_window_begin_draw_frame() take a draw context ... instead of a gl context. This requires some refactoring in the way we mark the shared context as drawing: We now call begin_frame/end_frame() on it and ignore the call on the main context. Unfortunately we need to do this check in all vfuncs, which sucks. But I haven't found a better way.
2016-12-01 00:38:20 +00:00
wayland: Reset pending offset in GL path Otherwise GL surfaces that redraw without changing the hotspot have it applied on top every frame and quickly slide away. The cairo path and the X11 backend do not have this bug.
2023-03-15 23:11:40 +00:00
impl->pending_buffer_offset_x = 0;
impl->pending_buffer_offset_y = 0;
wayland/glcontext: Sync surface state before swapping buffers A side effect of eglSwapBuffers* is the EGL implementation calling wl_surface_commit() on the corresponding Wayland surface. Thus, before swapping buffers, we must synchronize the surface state (e.g. opaque region, window geometry, etc) that changed since the last buffer swap. Prior to this commit, this was done after eglSwapBuffers*, causing the surface state to always correspond to the previous buffer state. As of this commit this is now done before swapping the buffers, thus before wl_surface_commit().
2018-03-21 06:01:58 +00:00
gdk_wayland_surface_sync (surface);
wayland: Factor out frame timings request code Also call the code everywhere we draw and not just with Cairo.
2018-04-10 13:10:56 +00:00
gdk_wayland_surface_request_frame (surface);
wayland/glcontext: Sync surface state before swapping buffers A side effect of eglSwapBuffers* is the EGL implementation calling wl_surface_commit() on the corresponding Wayland surface. Thus, before swapping buffers, we must synchronize the surface state (e.g. opaque region, window geometry, etc) that changed since the last buffer swap. Prior to this commit, this was done after eglSwapBuffers*, causing the surface state to always correspond to the previous buffer state. As of this commit this is now done before swapping the buffers, thus before wl_surface_commit().
2018-03-21 06:01:58 +00:00
wayland/glcontext: Don't call wl_surface.offset on old objects The availability of wl_surface.offset depends on the compositor, so we can't call it unconditionally. Add a version check to so we only call offset if we know we won't raise a protocol error. Fixes: 0eb791eaaa ("Make mask nodes more versatile")
2023-02-17 10:59:14 +00:00
if (wl_surface_get_version (impl->display_server.wl_surface) >=
WL_SURFACE_OFFSET_SINCE_VERSION)
wl_surface_offset (impl->display_server.wl_surface, dx, dy);
Make mask nodes more versatile Add a GskMaskMode enumeration and implement it in the GL and cairo renderers.
2023-02-14 18:44:39 +00:00
egl: Unify contexts Unify the X11 and Wayland EGL contexts. This is a bit ugly to implement, because I don't want to create an interface and I can't make them inherit from the same object, because one needs to inherit from X11GLContext and the other from WaylandGLContext. So we have to put the code in GdkGLContext and make sure non-EGL contexts can't accidentally run it. This is rather easy because we can just check for priv->egl_context != NULL.
2021-10-05 22:34:10 +00:00
GDK_DRAW_CONTEXT_CLASS (gdk_wayland_gl_context_parent_class)->end_frame (draw_context, painted);
wayland/surface: Make sure to commit ack_configure We must wl_surface.commit after xdg_surface.ack_configure to make it have an effect. We failed to do so when a configure event didn't result in new updates, so make sure we fall back on an simple wl_surface.commit if there was no new actual frame painted. Closes: #2910
2020-09-17 16:20:08 +00:00
gdk_wayland_surface_notify_committed (surface);
wayland: Add OpenGL support This uses EGL to implement GdkGLContext for wayland.
2014-10-09 09:06:48 +00:00
}
static void
gdk_wayland_gl_context_class_init (GdkWaylandGLContextClass *klass)
{
gdk: Make gdk_window_begin_draw_frame() take a draw context ... instead of a gl context. This requires some refactoring in the way we mark the shared context as drawing: We now call begin_frame/end_frame() on it and ignore the call on the main context. Unfortunately we need to do this check in all vfuncs, which sucks. But I haven't found a better way.
2016-12-01 00:38:20 +00:00
GdkDrawContextClass *draw_context_class = GDK_DRAW_CONTEXT_CLASS (klass);
GL: Split GL context creation in two phases One of the major requests by OpenGL users has been the ability to specify settings when creating a GL context, like the version to use or whether the debug support should be enabled. We have a couple of requirements in terms of API: • avoid, if at all possible, the "C arrays of integers with attribute, value pairs", which are hard to write and hard to bind in non-C languages. • allow failing in a recoverable way. • do not make the GL context creation API a mess of arguments. Looking at prior art, it seems that a common pattern is to split the construction phase in two: • a first phase that creates a GL context wrapper object and does preliminary checks on the environment. • a second phase that creates the backend-specific GL object. We adopted a similar pattern: • gdk_window_create_gl_context() creates a GdkGLContext • gdk_gl_context_realize() creates the underlying resources Calling gdk_gl_context_make_current() also realizes the context, so simple GL users do not need to care. Advanced users will want to call gdk_window_create_gl_context(), set up the optional requirements, and then call gdk_gl_context_realize(). If either of these two steps fails, it's possible to recover by changing the requirements, or simply creating a new GdkGLContext instance. https://bugzilla.gnome.org/show_bug.cgi?id=741946
2015-01-27 21:23:23 +00:00
GdkGLContextClass *context_class = GDK_GL_CONTEXT_CLASS (klass);
wayland: Add OpenGL support This uses EGL to implement GdkGLContext for wayland.
2014-10-09 09:06:48 +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
draw_context_class->begin_frame = gdk_wayland_gl_context_begin_frame;
gdk: Make gdk_window_begin_draw_frame() take a draw context ... instead of a gl context. This requires some refactoring in the way we mark the shared context as drawing: We now call begin_frame/end_frame() on it and ignore the call on the main context. Unfortunately we need to do this check in all vfuncs, which sucks. But I haven't found a better way.
2016-12-01 00:38:20 +00:00
draw_context_class->end_frame = gdk_wayland_gl_context_end_frame;
GL: Split GL context creation in two phases One of the major requests by OpenGL users has been the ability to specify settings when creating a GL context, like the version to use or whether the debug support should be enabled. We have a couple of requirements in terms of API: • avoid, if at all possible, the "C arrays of integers with attribute, value pairs", which are hard to write and hard to bind in non-C languages. • allow failing in a recoverable way. • do not make the GL context creation API a mess of arguments. Looking at prior art, it seems that a common pattern is to split the construction phase in two: • a first phase that creates a GL context wrapper object and does preliminary checks on the environment. • a second phase that creates the backend-specific GL object. We adopted a similar pattern: • gdk_window_create_gl_context() creates a GdkGLContext • gdk_gl_context_realize() creates the underlying resources Calling gdk_gl_context_make_current() also realizes the context, so simple GL users do not need to care. Advanced users will want to call gdk_window_create_gl_context(), set up the optional requirements, and then call gdk_gl_context_realize(). If either of these two steps fails, it's possible to recover by changing the requirements, or simply creating a new GdkGLContext instance. https://bugzilla.gnome.org/show_bug.cgi?id=741946
2015-01-27 21:23:23 +00:00
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;
wayland: Add OpenGL support This uses EGL to implement GdkGLContext for wayland.
2014-10-09 09:06:48 +00:00
}
static void
gdk_wayland_gl_context_init (GdkWaylandGLContext *self)
{
}
wayland: Add EGLDisplay getter Getting an EGLDisplay object is messy; might as well expose the function we use internally to save some time, just like we did for the X11 backend.
2021-05-11 11:26:55 +00:00
/**
* gdk_wayland_display_get_egl_display:
* @display: (type GdkWaylandDisplay): a Wayland display
*
* Retrieves the EGL display connection object for the given GDK display.
*
* Returns: (nullable): the EGL display
Add missing "Since: 4.X" tags Signed-off-by: Marc-André Lureau <marcandre.lureau@redhat.com>
2021-07-07 16:18:28 +00:00
*
* Since: 4.4
wayland: Add EGLDisplay getter Getting an EGLDisplay object is messy; might as well expose the function we use internally to save some time, just like we did for the X11 backend.
2021-05-11 11:26:55 +00:00
*/
gpointer
gdk_wayland_display_get_egl_display (GdkDisplay *display)
{
g_return_val_if_fail (GDK_IS_WAYLAND_DISPLAY (display), NULL);
egl: Move initialization code and port Wayland Moves the EGL initialization code to gdk/ so it can be shared between backends. Also port the Wayland backend to this code, so I know that it works.
2021-10-03 04:22:21 +00:00
return gdk_display_get_egl_display (display);
Use eglGetPlatformDisplay{,EXT} if available Calling eglGetDisplay forces libEGL to guess what kind of pointer you passed it. Different EGL libraries will do different things here, and in particular glvnd will do something different than Mesa. Since we do have an API that allows us to explicitly type the display, use it. The explicit call to eglGetProcAddress is working around a bug in libepoxy 1.3, which does not understand the EGL concept of client extensions. Since it does not, the normal epoxy resolver for eglGetPlatformDisplayEXT would not find any provider for that entry point, and crash when you attempted to call it. Signed-off-by: Adam Jackson <ajax@redhat.com> https://bugzilla.gnome.org/show_bug.cgi?id=772415
2016-10-10 18:12:40 +00:00
}
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 *
wayland: Move fbconfig into the display Create it during init and then reuse it for all contexts. While doing that, also improve error reporting - that's not used yet but will in later commits.
2021-07-04 17:48:11 +00:00
gdk_wayland_display_init_gl (GdkDisplay *display,
GError **error)
wayland: Add OpenGL support This uses EGL to implement GdkGLContext for wayland.
2014-10-09 09:06:48 +00:00
{
egl: Move initialization code and port Wayland Moves the EGL initialization code to gdk/ so it can be shared between backends. Also port the Wayland backend to this code, so I know that it works.
2021-10-03 04:22:21 +00:00
GdkWaylandDisplay *self = GDK_WAYLAND_DISPLAY (display);
wayland: Reset pending offset in GL path Otherwise GL surfaces that redraw without changing the hotspot have it applied on top every frame and quickly slide away. The cairo path and the X11 backend do not have this bug.
2023-03-15 23:11:40 +00:00
if (!gdk_display_init_egl (display,
egl: Move initialization code and port Wayland Moves the EGL initialization code to gdk/ so it can be shared between backends. Also port the Wayland backend to this code, so I know that it works.
2021-10-03 04:22:21 +00:00
EGL_PLATFORM_WAYLAND_EXT,
self->wl_display,
TRUE,
error))
return NULL;
wayland: Add OpenGL support This uses EGL to implement GdkGLContext for wayland.
2014-10-09 09:06:48 +00:00
egl: Move initialization code and port Wayland Moves the EGL initialization code to gdk/ so it can be shared between backends. Also port the Wayland backend to this code, so I know that it works.
2021-10-03 04:22:21 +00:00
return g_object_new (GDK_TYPE_WAYLAND_GL_CONTEXT,
"display", display,
NULL);
wayland: Add OpenGL support This uses EGL to implement GdkGLContext for wayland.
2014-10-09 09:06:48 +00:00
}
Reference in New Issue Copy Permalink