AuroraMiddleware/gtk2
1
0
Fork 0
forked from AuroraMiddleware/gtk
Code Issues Pull Requests Projects Releases Wiki Activity
03cc603093
gtk2/gdk/wayland/gdkglcontext-wayland.c

428 lines
14 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"
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"
wayland: Better error on eglGetDisplay() failure Goals: 1. Provide as much information as possible in the error message, so users can try to fix their system themselves. 2. Try to formulate the error message in a way that explains that this is not something GTK can fix, but a lower layer problem. Related: #4193
2021-08-24 19:27:49 +00:00
#include "gdk-private.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
#include "gdkintl.h"
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)
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
static void gdk_wayland_gl_context_dispose (GObject *gobject);
GdkGLContext: Change the way we track the current context To properly support multithreaded use we use a global GPrivate to track the current context. Since we also don't need to track the current context on the display we move gdk_display_destroy_gl_context to GdkGLContext::discard.
2014-10-30 10:46:09 +00:00
wayland/gl: Ensure we use the 3.2 core profile Emit an error if the profile is different. https://bugzilla.gnome.org/show_bug.cgi?id=741946
2015-02-09 15:56:18 +00:00
#define N_EGL_ATTRS 16
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
static gboolean
gdk_wayland_gl_context_realize (GdkGLContext *context,
GError **error)
{
GdkWaylandGLContext *context_wayland = GDK_WAYLAND_GL_CONTEXT (context);
GdkDisplay *display = gdk_gl_context_get_display (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
GdkGLContext *share = gdk_display_get_gl_context (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
EGLDisplay egl_display = gdk_display_get_egl_display (display);
EGLConfig egl_config = gdk_display_get_egl_config (display);
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
EGLContext ctx;
wayland/gl: Ensure we use the 3.2 core profile Emit an error if the profile is different. https://bugzilla.gnome.org/show_bug.cgi?id=741946
2015-02-09 15:56:18 +00:00
EGLint context_attribs[N_EGL_ATTRS];
int major, minor, flags;
wayland: Implement asking for a GLES context Wayland uses EGL, which allows us to ask for a GLES context. https://bugzilla.gnome.org/show_bug.cgi?id=743746
2016-04-18 09:13:05 +00:00
gboolean debug_bit, forward_bit, legacy_bit, use_es;
wayland/gl: Ensure we use the 3.2 core profile Emit an error if the profile is different. https://bugzilla.gnome.org/show_bug.cgi?id=741946
2015-02-09 15:56:18 +00:00
int i = 0;
Add more sysprof marks Add a few more marks during gtk_init to figure out where our startup time goes, and avoid the sysprof initialization from distorting the first mark.
2021-07-22 15:36:29 +00:00
G_GNUC_UNUSED gint64 start_time = GDK_PROFILER_CURRENT_TIME;
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
wayland/gl: Ensure we use the 3.2 core profile Emit an error if the profile is different. https://bugzilla.gnome.org/show_bug.cgi?id=741946
2015-02-09 15:56:18 +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);
Make gdk logging per-display As far as possible, use per-display debug flags. This will minimize the debug spew that we get from the inspector if it is running on a separate display.
2018-01-12 00:48:27 +00:00
legacy_bit = GDK_DISPLAY_DEBUG_CHECK (display, GL_LEGACY) ||
wayland: Allow falling back to compatibility EGL contexts If the shared context is in legacy mode, or if the creation of a core profile context failed, we fall back to an EGL context in compatibility mode. Since we're relying on a fairly new EGL implementation for Wayland, we don't fall back to the older EGL API, and instead we always require the EGL_KHR_create_context extension. https://bugzilla.gnome.org/show_bug.cgi?id=756142
2015-10-07 14:26:53 +00:00
(share != NULL && gdk_gl_context_is_legacy (share));
Make gdk logging per-display As far as possible, use per-display debug flags. This will minimize the debug spew that we get from the inspector if it is running on a separate display.
2018-01-12 00:48:27 +00:00
use_es = GDK_DISPLAY_DEBUG_CHECK (display, GL_GLES) ||
wayland: Honour GDK_GL=gles on context creation
2016-04-22 11:45:32 +00:00
(share != NULL && gdk_gl_context_get_use_es (share));
wayland/gl: Ensure we use the 3.2 core profile Emit an error if the profile is different. https://bugzilla.gnome.org/show_bug.cgi?id=741946
2015-02-09 15:56:18 +00:00
flags = 0;
if (debug_bit)
flags |= EGL_CONTEXT_OPENGL_DEBUG_BIT_KHR;
if (forward_bit)
flags |= EGL_CONTEXT_OPENGL_FORWARD_COMPATIBLE_BIT_KHR;
wayland: Implement asking for a GLES context Wayland uses EGL, which allows us to ask for a GLES context. https://bugzilla.gnome.org/show_bug.cgi?id=743746
2016-04-18 09:13:05 +00:00
if (!use_es)
{
wayland: Bind the appropriate OpenGL API If we want to use OpenGL ES with EGL then we need to bind the API before creating the EGL context.
2016-04-23 09:13:39 +00:00
eglBindAPI (EGL_OPENGL_API);
wayland: Implement asking for a GLES context Wayland uses EGL, which allows us to ask for a GLES context. https://bugzilla.gnome.org/show_bug.cgi?id=743746
2016-04-18 09:13:05 +00:00
/* We want a core profile, unless in legacy mode */
context_attribs[i++] = EGL_CONTEXT_OPENGL_PROFILE_MASK_KHR;
context_attribs[i++] = legacy_bit
? EGL_CONTEXT_OPENGL_COMPATIBILITY_PROFILE_BIT_KHR
: EGL_CONTEXT_OPENGL_CORE_PROFILE_BIT_KHR;
/* Specify the version */
context_attribs[i++] = EGL_CONTEXT_MAJOR_VERSION_KHR;
context_attribs[i++] = legacy_bit ? 3 : major;
context_attribs[i++] = EGL_CONTEXT_MINOR_VERSION_KHR;
context_attribs[i++] = legacy_bit ? 0 : minor;
}
else
{
wayland: Bind the appropriate OpenGL API If we want to use OpenGL ES with EGL then we need to bind the API before creating the EGL context.
2016-04-23 09:13:39 +00:00
eglBindAPI (EGL_OPENGL_ES_API);
wayland: Implement asking for a GLES context Wayland uses EGL, which allows us to ask for a GLES context. https://bugzilla.gnome.org/show_bug.cgi?id=743746
2016-04-18 09:13:05 +00:00
context_attribs[i++] = EGL_CONTEXT_CLIENT_VERSION;
if (major == 3)
context_attribs[i++] = 3;
else
context_attribs[i++] = 2;
}
wayland/gl: Ensure we use the 3.2 core profile Emit an error if the profile is different. https://bugzilla.gnome.org/show_bug.cgi?id=741946
2015-02-09 15:56:18 +00:00
/* Specify the flags */
context_attribs[i++] = EGL_CONTEXT_FLAGS_KHR;
context_attribs[i++] = flags;
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
context_attribs[i++] = EGL_NONE;
wayland/gl: Ensure we use the 3.2 core profile Emit an error if the profile is different. https://bugzilla.gnome.org/show_bug.cgi?id=741946
2015-02-09 15:56:18 +00:00
g_assert (i < N_EGL_ATTRS);
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
Make gdk logging per-display As far as possible, use per-display debug flags. This will minimize the debug spew that we get from the inspector if it is running on a separate display.
2018-01-12 00:48:27 +00:00
GDK_DISPLAY_NOTE (display, OPENGL,
g_message ("Creating EGL context version %d.%d (debug:%s, forward:%s, legacy:%s, es:%s)",
wayland: Add debugging notes for EGL context creation
2016-04-22 17:50:50 +00:00
major, minor,
debug_bit ? "yes" : "no",
forward_bit ? "yes" : "no",
legacy_bit ? "yes" : "no",
use_es ? "yes" : "no"));
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
ctx = eglCreateContext (egl_display,
egl_config,
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
share != NULL ? GDK_WAYLAND_GL_CONTEXT (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,
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
context_attribs);
wayland: Allow falling back to compatibility EGL contexts If the shared context is in legacy mode, or if the creation of a core profile context failed, we fall back to an EGL context in compatibility mode. Since we're relying on a fairly new EGL implementation for Wayland, we don't fall back to the older EGL API, and instead we always require the EGL_KHR_create_context extension. https://bugzilla.gnome.org/show_bug.cgi?id=756142
2015-10-07 14:26:53 +00:00
gdkglcontext-wayland: Fallback to GLES 2.0 after legacy failed This lets the NGL backend be selected instead of the Cairo backend on devices which expose both GL and GLES, but have better support of GLES. Tested on a PinePhone.
2021-03-21 20:02:08 +00:00
/* If context creation failed without the ES bit, let's try again with it */
if (ctx == NULL)
{
i = 0;
context_attribs[i++] = EGL_CONTEXT_MAJOR_VERSION;
context_attribs[i++] = 2;
context_attribs[i++] = EGL_CONTEXT_MINOR_VERSION;
context_attribs[i++] = 0;
context_attribs[i++] = EGL_CONTEXT_FLAGS_KHR;
context_attribs[i++] = flags & ~EGL_CONTEXT_OPENGL_FORWARD_COMPATIBLE_BIT_KHR;
context_attribs[i++] = EGL_NONE;
g_assert (i < N_EGL_ATTRS);
eglBindAPI (EGL_OPENGL_ES_API);
legacy_bit = FALSE;
use_es = TRUE;
GDK_DISPLAY_NOTE (display, OPENGL,
g_message ("eglCreateContext failed, switching to OpenGL ES"));
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
ctx = eglCreateContext (egl_display,
egl_config,
gdkglcontext-wayland: Fallback to GLES 2.0 after legacy failed This lets the NGL backend be selected instead of the Cairo backend on devices which expose both GL and GLES, but have better support of GLES. Tested on a PinePhone.
2021-03-21 20:02:08 +00:00
share != NULL ? GDK_WAYLAND_GL_CONTEXT (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,
gdkglcontext-wayland: Fallback to GLES 2.0 after legacy failed This lets the NGL backend be selected instead of the Cairo backend on devices which expose both GL and GLES, but have better support of GLES. Tested on a PinePhone.
2021-03-21 20:02:08 +00:00
context_attribs);
}
wayland: Allow falling back to compatibility EGL contexts If the shared context is in legacy mode, or if the creation of a core profile context failed, we fall back to an EGL context in compatibility mode. Since we're relying on a fairly new EGL implementation for Wayland, we don't fall back to the older EGL API, and instead we always require the EGL_KHR_create_context extension. https://bugzilla.gnome.org/show_bug.cgi?id=756142
2015-10-07 14:26:53 +00:00
/* If context creation failed without the legacy bit, let's try again with it */
gdkglcontext-wayland: Fallback to GLES 2.0 after legacy failed This lets the NGL backend be selected instead of the Cairo backend on devices which expose both GL and GLES, but have better support of GLES. Tested on a PinePhone.
2021-03-21 20:02:08 +00:00
if (ctx == NULL)
wayland: Allow falling back to compatibility EGL contexts If the shared context is in legacy mode, or if the creation of a core profile context failed, we fall back to an EGL context in compatibility mode. Since we're relying on a fairly new EGL implementation for Wayland, we don't fall back to the older EGL API, and instead we always require the EGL_KHR_create_context extension. https://bugzilla.gnome.org/show_bug.cgi?id=756142
2015-10-07 14:26:53 +00:00
{
gdkglcontext-wayland: Fallback to GLES 2.0 after legacy failed This lets the NGL backend be selected instead of the Cairo backend on devices which expose both GL and GLES, but have better support of GLES. Tested on a PinePhone.
2021-03-21 20:02:08 +00:00
i = 0;
context_attribs[i++] = EGL_CONTEXT_OPENGL_PROFILE_MASK_KHR;
context_attribs[i++] = EGL_CONTEXT_OPENGL_COMPATIBILITY_PROFILE_BIT_KHR;
context_attribs[i++] = EGL_CONTEXT_MAJOR_VERSION;
context_attribs[i++] = 3;
context_attribs[i++] = EGL_CONTEXT_MINOR_VERSION;
context_attribs[i++] = 0;
context_attribs[i++] = EGL_CONTEXT_FLAGS_KHR;
context_attribs[i++] = flags & ~EGL_CONTEXT_OPENGL_FORWARD_COMPATIBLE_BIT_KHR;
context_attribs[i++] = EGL_NONE;
g_assert (i < N_EGL_ATTRS);
wayland: Allow falling back to compatibility EGL contexts If the shared context is in legacy mode, or if the creation of a core profile context failed, we fall back to an EGL context in compatibility mode. Since we're relying on a fairly new EGL implementation for Wayland, we don't fall back to the older EGL API, and instead we always require the EGL_KHR_create_context extension. https://bugzilla.gnome.org/show_bug.cgi?id=756142
2015-10-07 14:26:53 +00:00
wayland: Bind the appropriate OpenGL API If we want to use OpenGL ES with EGL then we need to bind the API before creating the EGL context.
2016-04-23 09:13:39 +00:00
eglBindAPI (EGL_OPENGL_API);
wayland: Allow falling back to compatibility EGL contexts If the shared context is in legacy mode, or if the creation of a core profile context failed, we fall back to an EGL context in compatibility mode. Since we're relying on a fairly new EGL implementation for Wayland, we don't fall back to the older EGL API, and instead we always require the EGL_KHR_create_context extension. https://bugzilla.gnome.org/show_bug.cgi?id=756142
2015-10-07 14:26:53 +00:00
legacy_bit = TRUE;
wayland: Add debugging notes for EGL context creation
2016-04-22 17:50:50 +00:00
use_es = FALSE;
wayland: Allow falling back to compatibility EGL contexts If the shared context is in legacy mode, or if the creation of a core profile context failed, we fall back to an EGL context in compatibility mode. Since we're relying on a fairly new EGL implementation for Wayland, we don't fall back to the older EGL API, and instead we always require the EGL_KHR_create_context extension. https://bugzilla.gnome.org/show_bug.cgi?id=756142
2015-10-07 14:26:53 +00:00
Make gdk logging per-display As far as possible, use per-display debug flags. This will minimize the debug spew that we get from the inspector if it is running on a separate display.
2018-01-12 00:48:27 +00:00
GDK_DISPLAY_NOTE (display, OPENGL,
g_message ("eglCreateContext failed, switching to legacy"));
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
ctx = eglCreateContext (egl_display,
egl_config,
wayland: Allow falling back to compatibility EGL contexts If the shared context is in legacy mode, or if the creation of a core profile context failed, we fall back to an EGL context in compatibility mode. Since we're relying on a fairly new EGL implementation for Wayland, we don't fall back to the older EGL API, and instead we always require the EGL_KHR_create_context extension. https://bugzilla.gnome.org/show_bug.cgi?id=756142
2015-10-07 14:26:53 +00:00
share != NULL ? GDK_WAYLAND_GL_CONTEXT (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,
wayland: Allow falling back to compatibility EGL contexts If the shared context is in legacy mode, or if the creation of a core profile context failed, we fall back to an EGL context in compatibility mode. Since we're relying on a fairly new EGL implementation for Wayland, we don't fall back to the older EGL API, and instead we always require the EGL_KHR_create_context extension. https://bugzilla.gnome.org/show_bug.cgi?id=756142
2015-10-07 14:26:53 +00:00
context_attribs);
}
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
if (ctx == NULL)
{
g_set_error_literal (error, GDK_GL_ERROR,
GDK_GL_ERROR_NOT_AVAILABLE,
_("Unable to create a GL context"));
return FALSE;
}
Make gdk logging per-display As far as possible, use per-display debug flags. This will minimize the debug spew that we get from the inspector if it is running on a separate display.
2018-01-12 00:48:27 +00:00
GDK_DISPLAY_NOTE (display, OPENGL, g_message ("Created EGL context[%p]", ctx));
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
context_wayland->egl_context = ctx;
wayland: Allow falling back to compatibility EGL contexts If the shared context is in legacy mode, or if the creation of a core profile context failed, we fall back to an EGL context in compatibility mode. Since we're relying on a fairly new EGL implementation for Wayland, we don't fall back to the older EGL API, and instead we always require the EGL_KHR_create_context extension. https://bugzilla.gnome.org/show_bug.cgi?id=756142
2015-10-07 14:26:53 +00:00
gdk_gl_context_set_is_legacy (context, legacy_bit);
wayland: Honour GDK_GL=gles on context creation
2016-04-22 11:45:32 +00:00
gdk_gl_context_set_use_es (context, use_es);
wayland: Allow falling back to compatibility EGL contexts If the shared context is in legacy mode, or if the creation of a core profile context failed, we fall back to an EGL context in compatibility mode. Since we're relying on a fairly new EGL implementation for Wayland, we don't fall back to the older EGL API, and instead we always require the EGL_KHR_create_context extension. https://bugzilla.gnome.org/show_bug.cgi?id=756142
2015-10-07 14:26:53 +00:00
Add more sysprof marks Add a few more marks during gtk_init to figure out where our startup time goes, and avoid the sysprof initialization from distorting the first mark.
2021-07-22 15:36:29 +00:00
gdk_profiler_end_mark (start_time, "realize GdkWaylandGLContext", NULL);
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
return TRUE;
}
gdkgl: Add gdk_gl_context_get_damage() This is a way to query the damaged area of the backbuffer. The GL renderer uses this to compute the extents of that damage region (computed via buffer age) and use them to minimize the area to redraw. This changes the semantics of GL rendering to "When calling gdk_window_begin_frame() with a GL context, the area by gdk_gl_context_get_damage() needs to be redrawn and every other pixel of the backbuffer is guaranteed to be correct. After gdk_window_end_frame() on a GL-drawn window, the whole backbuffer must be correct. We can always glXBufferSwap() now because of this.
2016-12-04 15:33:13 +00:00
static cairo_region_t *
gdk_wayland_gl_context_get_damage (GdkGLContext *context)
{
GdkDisplay *display = gdk_draw_context_get_display (GDK_DRAW_CONTEXT (context));
EGLSurface egl_surface;
GdkSurface: Rename lots of stuff from window->surface Mostly these are internal things, but the major public change is that event.window is now event.surface.
2018-03-20 14:14:10 +00:00
GdkSurface *surface = gdk_draw_context_get_surface (GDK_DRAW_CONTEXT (context));
gdkgl: Add gdk_gl_context_get_damage() This is a way to query the damaged area of the backbuffer. The GL renderer uses this to compute the extents of that damage region (computed via buffer age) and use them to minimize the area to redraw. This changes the semantics of GL rendering to "When calling gdk_window_begin_frame() with a GL context, the area by gdk_gl_context_get_damage() needs to be redrawn and every other pixel of the backbuffer is guaranteed to be correct. After gdk_window_end_frame() on a GL-drawn window, the whole backbuffer must be correct. We can always glXBufferSwap() now because of this.
2016-12-04 15:33:13 +00:00
int buffer_age = 0;
egl: Move extension checks to GdkDisplay We check the same extensions anyway, so no need to duplicate the code.
2021-10-05 22:48:33 +00:00
if (display->have_egl_buffer_age)
gdkgl: Add gdk_gl_context_get_damage() This is a way to query the damaged area of the backbuffer. The GL renderer uses this to compute the extents of that damage region (computed via buffer age) and use them to minimize the area to redraw. This changes the semantics of GL rendering to "When calling gdk_window_begin_frame() with a GL context, the area by gdk_gl_context_get_damage() needs to be redrawn and every other pixel of the backbuffer is guaranteed to be correct. After gdk_window_end_frame() on a GL-drawn window, the whole backbuffer must be correct. We can always glXBufferSwap() now because of this.
2016-12-04 15:33:13 +00:00
{
egl: Move EGLSurface handling to GdkSurface Calling gdk_surface_set_egl_native_window() enables this.
2021-10-03 19:58:57 +00:00
egl_surface = gdk_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);
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
eglQuerySurface (gdk_display_get_egl_display (display), egl_surface,
gdkgl: Add gdk_gl_context_get_damage() This is a way to query the damaged area of the backbuffer. The GL renderer uses this to compute the extents of that damage region (computed via buffer age) and use them to minimize the area to redraw. This changes the semantics of GL rendering to "When calling gdk_window_begin_frame() with a GL context, the area by gdk_gl_context_get_damage() needs to be redrawn and every other pixel of the backbuffer is guaranteed to be correct. After gdk_window_end_frame() on a GL-drawn window, the whole backbuffer must be correct. We can always glXBufferSwap() now because of this.
2016-12-04 15:33:13 +00:00
EGL_BUFFER_AGE_EXT, &buffer_age);
GdkGLContext: Fix damage computation with buffer_age As per the spec: > The back buffer can > either be reported as invalid (has an age of 0) or it may be > reported to contain the contents from n frames prior to the > current frame. So a buffer age of 1 means that the buffer was used in the last frame. We were handling buffer_age==1 the same as buffer_age==0, i.e. we returned the full damage for the surface. [1] https://www.khronos.org/registry/EGL/extensions/EXT/EGL_EXT_buffer_age.txt
2018-11-30 12:14:00 +00:00
switch (buffer_age)
gdkgl: Add gdk_gl_context_get_damage() This is a way to query the damaged area of the backbuffer. The GL renderer uses this to compute the extents of that damage region (computed via buffer age) and use them to minimize the area to redraw. This changes the semantics of GL rendering to "When calling gdk_window_begin_frame() with a GL context, the area by gdk_gl_context_get_damage() needs to be redrawn and every other pixel of the backbuffer is guaranteed to be correct. After gdk_window_end_frame() on a GL-drawn window, the whole backbuffer must be correct. We can always glXBufferSwap() now because of this.
2016-12-04 15:33:13 +00:00
{
GdkGLContext: Fix damage computation with buffer_age As per the spec: > The back buffer can > either be reported as invalid (has an age of 0) or it may be > reported to contain the contents from n frames prior to the > current frame. So a buffer age of 1 means that the buffer was used in the last frame. We were handling buffer_age==1 the same as buffer_age==0, i.e. we returned the full damage for the surface. [1] https://www.khronos.org/registry/EGL/extensions/EXT/EGL_EXT_buffer_age.txt
2018-11-30 12:14:00 +00:00
case 1:
return cairo_region_create ();
break;
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:
;
gdkgl: Add gdk_gl_context_get_damage() This is a way to query the damaged area of the backbuffer. The GL renderer uses this to compute the extents of that damage region (computed via buffer age) and use them to minimize the area to redraw. This changes the semantics of GL rendering to "When calling gdk_window_begin_frame() with a GL context, the area by gdk_gl_context_get_damage() needs to be redrawn and every other pixel of the backbuffer is guaranteed to be correct. After gdk_window_end_frame() on a GL-drawn window, the whole backbuffer must be correct. We can always glXBufferSwap() now because of this.
2016-12-04 15:33:13 +00:00
}
}
return GDK_GL_CONTEXT_CLASS (gdk_wayland_gl_context_parent_class)->get_damage (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
static gboolean
gdk_wayland_gl_context_clear_current (GdkGLContext *context)
{
GdkDisplay *display = gdk_gl_context_get_display (context);
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 eglMakeCurrent (gdk_display_get_egl_display (display),
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
EGL_NO_SURFACE,
EGL_NO_SURFACE,
EGL_NO_CONTEXT);
}
static gboolean
gdk_wayland_gl_context_make_current (GdkGLContext *context,
gboolean surfaceless)
{
GdkWaylandGLContext *context_wayland = GDK_WAYLAND_GL_CONTEXT (context);
GdkDisplay *display = gdk_gl_context_get_display (context);
EGLSurface egl_surface;
if (!surfaceless)
egl: Move EGLSurface handling to GdkSurface Calling gdk_surface_set_egl_native_window() enables this.
2021-10-03 19:58:57 +00:00
egl_surface = gdk_surface_get_egl_surface (gdk_gl_context_get_surface (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
else
egl_surface = EGL_NO_SURFACE;
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 eglMakeCurrent (gdk_display_get_egl_display (display),
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
egl_surface,
egl_surface,
context_wayland->egl_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,
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));
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
GDK_DRAW_CONTEXT_CLASS (gdk_wayland_gl_context_parent_class)->begin_frame (draw_context, region);
glDrawBuffers (1, (GLenum[1]) { GL_BACK });
}
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
{
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
GdkGLContext *context = GDK_GL_CONTEXT (draw_context);
GdkSurface: Rename lots of stuff from window->surface Mostly these are internal things, but the major public change is that event.window is now event.surface.
2018-03-20 14:14:10 +00:00
GdkSurface *surface = gdk_gl_context_get_surface (context);
GdkDisplay *display = gdk_surface_get_display (surface);
wayland: Add OpenGL support This uses EGL to implement GdkGLContext for wayland.
2014-10-09 09:06:48 +00:00
EGLSurface egl_surface;
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
GDK_DRAW_CONTEXT_CLASS (gdk_wayland_gl_context_parent_class)->end_frame (draw_context, painted);
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_gl_context_make_current (context);
wayland: Add OpenGL support This uses EGL to implement GdkGLContext for wayland.
2014-10-09 09:06:48 +00:00
egl: Move EGLSurface handling to GdkSurface Calling gdk_surface_set_egl_native_window() enables this.
2021-10-03 19:58:57 +00:00
egl_surface = gdk_surface_get_egl_surface (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
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
Port tracing to the sysprof collector api Use the new sysprof collector api to do tracing.
2020-08-19 22:49:34 +00:00
gdk_profiler_add_mark (GDK_PROFILER_CURRENT_TIME, 0, "wayland", "swap buffers");
egl: Move extension checks to GdkDisplay We check the same extensions anyway, so no need to duplicate the code.
2021-10-05 22:48:33 +00:00
if (display->have_egl_swap_buffers_with_damage)
wayland: Add OpenGL support This uses EGL to implement GdkGLContext for wayland.
2014-10-09 09:06:48 +00:00
{
glcontext-wayland: Avoid heap-alloacting small arrays... every frame.
2020-12-24 08:27:31 +00:00
EGLint stack_rects[4 * 4]; /* 4 rects */
EGLint *heap_rects = NULL;
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
int i, j, n_rects = cairo_region_num_rectangles (painted);
GdkSurface: Rename lots of stuff from window->surface Mostly these are internal things, but the major public change is that event.window is now event.surface.
2018-03-20 14:14:10 +00:00
int surface_height = gdk_surface_get_height (surface);
wayland/glcontext: Fix damage region on HiDPI The passed regions are in surface coordinates, but eglSwapBuffersWithDamage() is in buffer coordinates.
2019-12-03 15:32:59 +00:00
int scale = gdk_surface_get_scale_factor (surface);
glcontext-wayland: Avoid heap-alloacting small arrays... every frame.
2020-12-24 08:27:31 +00:00
EGLint *rects;
if (n_rects < G_N_ELEMENTS (stack_rects) / 4)
rects = (EGLint *)&stack_rects;
else
heap_rects = rects = g_new (EGLint, n_rects * 4);
wayland: Add OpenGL support This uses EGL to implement GdkGLContext for wayland.
2014-10-09 09:06:48 +00:00
for (i = 0, j = 0; i < n_rects; i++)
{
glcontext-wayland: Avoid heap-alloacting small arrays... every frame.
2020-12-24 08:27:31 +00:00
cairo_rectangle_int_t rect;
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_get_rectangle (painted, i, &rect);
wayland/glcontext: Fix damage region on HiDPI The passed regions are in surface coordinates, but eglSwapBuffersWithDamage() is in buffer coordinates.
2019-12-03 15:32:59 +00:00
rects[j++] = rect.x * scale;
rects[j++] = (surface_height - rect.height - rect.y) * scale;
rects[j++] = rect.width * scale;
rects[j++] = rect.height * scale;
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
eglSwapBuffersWithDamageEXT (gdk_display_get_egl_display (display), egl_surface, rects, n_rects);
glcontext-wayland: Avoid heap-alloacting small arrays... every frame.
2020-12-24 08:27:31 +00:00
g_free (heap_rects);
wayland: Add OpenGL support This uses EGL to implement GdkGLContext for wayland.
2014-10-09 09:06:48 +00:00
}
else
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
eglSwapBuffers (gdk_display_get_egl_display (display), egl_surface);
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)
{
GdkGLContext: Change the way we track the current context To properly support multithreaded use we use a global GPrivate to track the current context. Since we also don't need to track the current context on the display we move gdk_display_destroy_gl_context to GdkGLContext::discard.
2014-10-30 10:46:09 +00:00
GObjectClass *gobject_class = G_OBJECT_CLASS (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
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
gobject_class->dispose = gdk_wayland_gl_context_dispose;
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
context_class->realize = gdk_wayland_gl_context_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_wayland_gl_context_make_current;
context_class->clear_current = gdk_wayland_gl_context_clear_current;
gdkgl: Add gdk_gl_context_get_damage() This is a way to query the damaged area of the backbuffer. The GL renderer uses this to compute the extents of that damage region (computed via buffer age) and use them to minimize the area to redraw. This changes the semantics of GL rendering to "When calling gdk_window_begin_frame() with a GL context, the area by gdk_gl_context_get_damage() needs to be redrawn and every other pixel of the backbuffer is guaranteed to be correct. After gdk_window_end_frame() on a GL-drawn window, the whole backbuffer must be correct. We can always glXBufferSwap() now because of this.
2016-12-04 15:33:13 +00:00
context_class->get_damage = gdk_wayland_gl_context_get_damage;
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);
if (!gdk_display_init_egl (display,
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
}
GdkGLContext: Change the way we track the current context To properly support multithreaded use we use a global GPrivate to track the current context. Since we also don't need to track the current context on the display we move gdk_display_destroy_gl_context to GdkGLContext::discard.
2014-10-30 10:46:09 +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_dispose (GObject *gobject)
wayland: Add OpenGL support This uses EGL to implement GdkGLContext for wayland.
2014-10-09 09:06:48 +00:00
{
GdkGLContext: Change the way we track the current context To properly support multithreaded use we use a global GPrivate to track the current context. Since we also don't need to track the current context on the display we move gdk_display_destroy_gl_context to GdkGLContext::discard.
2014-10-30 10:46:09 +00:00
GdkWaylandGLContext *context_wayland = GDK_WAYLAND_GL_CONTEXT (gobject);
wayland: Add OpenGL support This uses EGL to implement GdkGLContext for wayland.
2014-10-09 09:06:48 +00:00
if (context_wayland->egl_context != NULL)
{
GdkGLContext: Change the way we track the current context To properly support multithreaded use we use a global GPrivate to track the current context. Since we also don't need to track the current context on the display we move gdk_display_destroy_gl_context to GdkGLContext::discard.
2014-10-30 10:46:09 +00:00
GdkGLContext *context = GDK_GL_CONTEXT (gobject);
GdkSurface: Rename lots of stuff from window->surface Mostly these are internal things, but the major public change is that event.window is now event.surface.
2018-03-20 14:14:10 +00:00
GdkSurface *surface = gdk_gl_context_get_surface (context);
GdkDisplay *display = gdk_surface_get_display (surface);
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
EGLDisplay *egl_display = gdk_display_get_egl_display (display);
GdkGLContext: Change the way we track the current context To properly support multithreaded use we use a global GPrivate to track the current context. Since we also don't need to track the current context on the display we move gdk_display_destroy_gl_context to GdkGLContext::discard.
2014-10-30 10:46:09 +00:00
wayland: Add OpenGL support This uses EGL to implement GdkGLContext for wayland.
2014-10-09 09:06:48 +00:00
if (eglGetCurrentContext () == context_wayland->egl_context)
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
eglMakeCurrent(egl_display, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT);
wayland: Add OpenGL support This uses EGL to implement GdkGLContext for wayland.
2014-10-09 09:06:48 +00:00
Make gdk logging per-display As far as possible, use per-display debug flags. This will minimize the debug spew that we get from the inspector if it is running on a separate display.
2018-01-12 00:48:27 +00:00
GDK_DISPLAY_NOTE (display, OPENGL, g_message ("Destroying EGL context"));
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
eglDestroyContext (egl_display, context_wayland->egl_context);
wayland: Add OpenGL support This uses EGL to implement GdkGLContext for wayland.
2014-10-09 09:06:48 +00:00
context_wayland->egl_context = NULL;
}
GdkGLContext: Change the way we track the current context To properly support multithreaded use we use a global GPrivate to track the current context. Since we also don't need to track the current context on the display we move gdk_display_destroy_gl_context to GdkGLContext::discard.
2014-10-30 10:46:09 +00:00
G_OBJECT_CLASS (gdk_wayland_gl_context_parent_class)->dispose (gobject);
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