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

542 lines
18 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"
#include "gdkdisplay-wayland.h"
#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"
#include "gdkinternals.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"
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);
GdkGLContext *share = gdk_gl_context_get_shared_context (context);
gdk: Create a global shared GL context Create a global GL context that connects all GL contexts on a display and lets us share textures between them.
2019-06-04 21:26:28 +00:00
GdkGLContext *shared_data_context = gdk_surface_get_shared_data_gl_context (gdk_gl_context_get_surface (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
GdkWaylandDisplay *display_wayland = GDK_WAYLAND_DISPLAY (display);
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;
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"));
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
ctx = eglCreateContext (display_wayland->egl_display,
context_wayland->egl_config,
share != NULL ? GDK_WAYLAND_GL_CONTEXT (share)->egl_context
gdk: Create a global shared GL context Create a global GL context that connects all GL contexts on a display and lets us share textures between them.
2019-06-04 21:26:28 +00:00
: shared_data_context != NULL ? GDK_WAYLAND_GL_CONTEXT (shared_data_context)->egl_context
: 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
/* If context creation failed without the legacy bit, let's try again with it */
if (ctx == NULL && !legacy_bit)
{
/* Ensure that re-ordering does not break the offsets */
g_assert (context_attribs[0] == EGL_CONTEXT_OPENGL_PROFILE_MASK_KHR);
context_attribs[1] = EGL_CONTEXT_OPENGL_COMPATIBILITY_PROFILE_BIT_KHR;
context_attribs[3] = 3;
context_attribs[5] = 0;
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"));
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
ctx = eglCreateContext (display_wayland->egl_display,
context_wayland->egl_config,
share != NULL ? GDK_WAYLAND_GL_CONTEXT (share)->egl_context
gdk: Create a global shared GL context Create a global GL context that connects all GL contexts on a display and lets us share textures between them.
2019-06-04 21:26:28 +00:00
: shared_data_context != NULL ? GDK_WAYLAND_GL_CONTEXT (shared_data_context)->egl_context
: 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
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));
GdkWaylandDisplay *display_wayland = GDK_WAYLAND_DISPLAY (display);
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;
if (display_wayland->have_egl_buffer_age)
{
GdkGLContext *shared;
GdkWaylandGLContext *shared_wayland;
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
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
shared = gdk_gl_context_get_shared_context (context);
if (shared == NULL)
shared = context;
shared_wayland = GDK_WAYLAND_GL_CONTEXT (shared);
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
egl_surface = gdk_wayland_surface_get_egl_surface (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
shared_wayland->egl_config);
gdk_gl_context_make_current (shared);
eglQuerySurface (display_wayland->egl_display, egl_surface,
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);
}
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
GdkWaylandDisplay *display_wayland = GDK_WAYLAND_DISPLAY (display);
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
GdkWaylandGLContext *context_wayland = GDK_WAYLAND_GL_CONTEXT (context);
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
if (gdk_gl_context_get_shared_context (context))
return;
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
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
egl_surface = gdk_wayland_surface_get_egl_surface (surface,
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
context_wayland->egl_config);
wayland: Add OpenGL support This uses EGL to implement GdkGLContext for wayland.
2014-10-09 09:06:48 +00:00
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
Convert all profiler times from nsec to usec usec is the scale of the monotonic timer which is where we get almost all the times from. The only actual source of nsec is the opengl GPU time (but who knows what the actual resulution of that is). Changing this to usec allows us to get rid of " * 1000" in a *lot* of places all over the codebase, which are ugly and confusing.
2020-02-12 09:44:17 +00:00
gdk_profiler_add_mark (g_get_monotonic_time (), 0, "wayland", "swap buffers");
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
if (display_wayland->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
{
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);
wayland: Add OpenGL support This uses EGL to implement GdkGLContext for wayland.
2014-10-09 09:06:48 +00:00
EGLint *rects = g_new (EGLint, n_rects * 4);
cairo_rectangle_int_t rect;
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);
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++)
{
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
}
eglSwapBuffersWithDamageEXT (display_wayland->egl_display, egl_surface, rects, n_rects);
g_free (rects);
}
else
eglSwapBuffers (display_wayland->egl_display, egl_surface);
}
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;
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;
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;
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)
{
}
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
static EGLDisplay
gdk_wayland_get_display (GdkWaylandDisplay *display_wayland)
{
EGLDisplay dpy = NULL;
if (epoxy_has_egl_extension (NULL, "EGL_KHR_platform_base"))
{
PFNEGLGETPLATFORMDISPLAYPROC getPlatformDisplay =
(void *) eglGetProcAddress ("eglGetPlatformDisplay");
if (getPlatformDisplay)
dpy = getPlatformDisplay (EGL_PLATFORM_WAYLAND_EXT,
display_wayland->wl_display,
NULL);
if (dpy)
return dpy;
}
if (epoxy_has_egl_extension (NULL, "EGL_EXT_platform_base"))
{
PFNEGLGETPLATFORMDISPLAYEXTPROC getPlatformDisplay =
(void *) eglGetProcAddress ("eglGetPlatformDisplayEXT");
if (getPlatformDisplay)
dpy = getPlatformDisplay (EGL_PLATFORM_WAYLAND_EXT,
display_wayland->wl_display,
NULL);
if (dpy)
return dpy;
}
return eglGetDisplay ((EGLNativeDisplayType) display_wayland->wl_display);
}
wayland: Add OpenGL support This uses EGL to implement GdkGLContext for wayland.
2014-10-09 09:06:48 +00:00
gboolean
gdk_wayland_display_init_gl (GdkDisplay *display)
{
GdkWaylandDisplay *display_wayland = GDK_WAYLAND_DISPLAY (display);
EGLint major, minor;
Fix some EGLDisplay * abuse EGLDisplays are already opaque pointers, and eglGetDisplay returns an EGLDisplay not a pointer to one. Signed-off-by: Adam Jackson <ajax@redhat.com> https://bugzilla.gnome.org/show_bug.cgi?id=772415
2016-10-10 18:10:38 +00:00
EGLDisplay dpy;
wayland: Add OpenGL support This uses EGL to implement GdkGLContext for wayland.
2014-10-09 09:06:48 +00:00
if (display_wayland->have_egl)
return TRUE;
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
dpy = gdk_wayland_get_display (display_wayland);
wayland: Add OpenGL support This uses EGL to implement GdkGLContext for wayland.
2014-10-09 09:06:48 +00:00
if (dpy == NULL)
return FALSE;
if (!eglInitialize (dpy, &major, &minor))
return FALSE;
if (!eglBindAPI (EGL_OPENGL_API))
return FALSE;
display_wayland->egl_display = dpy;
display_wayland->egl_major_version = major;
display_wayland->egl_minor_version = minor;
display_wayland->have_egl = TRUE;
display_wayland->have_egl_khr_create_context =
epoxy_has_egl_extension (dpy, "EGL_KHR_create_context");
display_wayland->have_egl_buffer_age =
epoxy_has_egl_extension (dpy, "EGL_EXT_buffer_age");
display_wayland->have_egl_swap_buffers_with_damage =
epoxy_has_egl_extension (dpy, "EGL_EXT_swap_buffers_with_damage");
gl: Make all user GdkGLContexts not attached to any window We make user facing gl contexts not attached to a surface if possible, or attached to dummy surfaces. This means nothing can accidentally read/write to the toplevel back buffer.
2014-10-09 14:09:05 +00:00
display_wayland->have_egl_surfaceless_context =
epoxy_has_egl_extension (dpy, "EGL_KHR_surfaceless_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
GDK_DISPLAY_NOTE (display, OPENGL,
wayland: Don't use g_print for debug output The g_print documentation explicitly says not to do this, since g_print is meant to be redirected by applications. Instead use g_message for logging that can be triggered via GTK_DEBUG.
2016-02-29 02:28:01 +00:00
g_message ("EGL API version %d.%d found\n"
" - Vendor: %s\n"
" - Version: %s\n"
" - Client APIs: %s\n"
" - Extensions:\n"
"\t%s",
display_wayland->egl_major_version,
display_wayland->egl_minor_version,
eglQueryString (dpy, EGL_VENDOR),
eglQueryString (dpy, EGL_VERSION),
eglQueryString (dpy, EGL_CLIENT_APIS),
eglQueryString (dpy, EGL_EXTENSIONS)));
wayland: Add OpenGL support This uses EGL to implement GdkGLContext for wayland.
2014-10-09 09:06:48 +00:00
return TRUE;
}
#define MAX_EGL_ATTRS 30
static gboolean
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
find_eglconfig_for_surface (GdkSurface *surface,
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
EGLConfig *egl_config_out,
GError **error)
wayland: Add OpenGL support This uses EGL to implement GdkGLContext for wayland.
2014-10-09 09:06:48 +00:00
{
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
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
GdkWaylandDisplay *display_wayland = GDK_WAYLAND_DISPLAY (display);
EGLint attrs[MAX_EGL_ATTRS];
EGLint count;
EGLConfig *configs;
int i = 0;
attrs[i++] = EGL_SURFACE_TYPE;
attrs[i++] = EGL_WINDOW_BIT;
attrs[i++] = EGL_COLOR_BUFFER_TYPE;
attrs[i++] = EGL_RGB_BUFFER;
attrs[i++] = EGL_RED_SIZE;
wayland: Explicitly require RGBA8888 Its the format we expect to have. If we want to support 10-bit visuals at some point, that should be an explicit decision.
2019-06-17 16:41:01 +00:00
attrs[i++] = 8;
wayland: Add OpenGL support This uses EGL to implement GdkGLContext for wayland.
2014-10-09 09:06:48 +00:00
attrs[i++] = EGL_GREEN_SIZE;
wayland: Explicitly require RGBA8888 Its the format we expect to have. If we want to support 10-bit visuals at some point, that should be an explicit decision.
2019-06-17 16:41:01 +00:00
attrs[i++] = 8;
wayland: Add OpenGL support This uses EGL to implement GdkGLContext for wayland.
2014-10-09 09:06:48 +00:00
attrs[i++] = EGL_BLUE_SIZE;
wayland: Explicitly require RGBA8888 Its the format we expect to have. If we want to support 10-bit visuals at some point, that should be an explicit decision.
2019-06-17 16:41:01 +00:00
attrs[i++] = 8;
API: gdk: Remove gdk_window_get_visual() With it, remove window->visual.
2016-10-27 21:27:49 +00:00
attrs[i++] = EGL_ALPHA_SIZE;
wayland: Explicitly require RGBA8888 Its the format we expect to have. If we want to support 10-bit visuals at some point, that should be an explicit decision.
2019-06-17 16:41:01 +00:00
attrs[i++] = 8;
wayland: Add OpenGL support This uses EGL to implement GdkGLContext for wayland.
2014-10-09 09:06:48 +00:00
attrs[i++] = EGL_NONE;
g_assert (i < MAX_EGL_ATTRS);
if (!eglChooseConfig (display_wayland->egl_display, attrs, NULL, 0, &count) || count < 1)
{
g_set_error_literal (error, GDK_GL_ERROR,
GDK_GL_ERROR_UNSUPPORTED_FORMAT,
_("No available configurations for the given pixel format"));
return FALSE;
}
configs = g_new (EGLConfig, count);
if (!eglChooseConfig (display_wayland->egl_display, attrs, configs, count, &count) || count < 1)
{
g_set_error_literal (error, GDK_GL_ERROR,
GDK_GL_ERROR_UNSUPPORTED_FORMAT,
_("No available configurations for the given pixel format"));
return FALSE;
}
/* Pick first valid configuration i guess? */
if (egl_config_out != NULL)
*egl_config_out = configs[0];
g_free (configs);
return TRUE;
}
GdkGLContext *
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
gdk_wayland_surface_create_gl_context (GdkSurface *surface,
gl: Make all user GdkGLContexts not attached to any window We make user facing gl contexts not attached to a surface if possible, or attached to dummy surfaces. This means nothing can accidentally read/write to the toplevel back buffer.
2014-10-09 14:09:05 +00:00
gboolean attached,
wayland: Add OpenGL support This uses EGL to implement GdkGLContext for wayland.
2014-10-09 09:06:48 +00:00
GdkGLContext *share,
GError **error)
{
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
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
GdkWaylandDisplay *display_wayland = GDK_WAYLAND_DISPLAY (display);
GdkWaylandGLContext *context;
EGLConfig config;
if (!gdk_wayland_display_init_gl (display))
{
g_set_error_literal (error, GDK_GL_ERROR,
GDK_GL_ERROR_NOT_AVAILABLE,
_("No GL implementation is available"));
return NULL;
}
gl: Drop profile for gdk_window_create_gl_context() Now that we have a two-stages GL context creation sequence, we can move the profile to a pre-realize option, like the debug and forward compatibility bits, or the GL version to use.
2015-02-12 12:34:28 +00:00
if (!display_wayland->have_egl_khr_create_context)
wayland: Add OpenGL support This uses EGL to implement GdkGLContext for wayland.
2014-10-09 09:06:48 +00:00
{
g_set_error_literal (error, GDK_GL_ERROR,
GDK_GL_ERROR_UNSUPPORTED_PROFILE,
Remove GdkGLProfile The existence of OpenGL implementations that do not provide the full core profile compatibility because of reasons beyond the technical, like llvmpipe not implementing floating point buffers, makes the existence of GdkGLProfile and documenting the fact that we use core profiles a bit harder. Since we do not have any existing profile except the default, we can remove the GdkGLProfile and its related API from GDK and GTK+, and sweep the whole thing under the carpet, while we wait for an extension that lets us ask for the most compatible profile possible. https://bugzilla.gnome.org/show_bug.cgi?id=744407
2015-02-12 17:30:42 +00:00
_("Core GL is not available on EGL implementation"));
wayland: Add OpenGL support This uses EGL to implement GdkGLContext for wayland.
2014-10-09 09:06:48 +00:00
return NULL;
}
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
if (!find_eglconfig_for_surface (surface, &config, error))
wayland: Add OpenGL support This uses EGL to implement GdkGLContext for wayland.
2014-10-09 09:06:48 +00:00
return NULL;
GL: Follow naming conventions All the GDK type defines are GDK_TYPE_..., so follow this pattern for the GLContext subclasses as well.
2014-10-22 03:39:05 +00:00
context = g_object_new (GDK_TYPE_WAYLAND_GL_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
"surface", surface,
GdkGLContext: Track shared context This allows us to read it back, but primarily it ensures the shared context wrapper stays alive as long as the context.
2014-10-30 11:04:23 +00:00
"shared-context", share,
wayland: Add OpenGL support This uses EGL to implement GdkGLContext for wayland.
2014-10-09 09:06:48 +00:00
NULL);
context->egl_config = config;
gl: Make all user GdkGLContexts not attached to any window We make user facing gl contexts not attached to a surface if possible, or attached to dummy surfaces. This means nothing can accidentally read/write to the toplevel back buffer.
2014-10-09 14:09:05 +00:00
context->is_attached = attached;
wayland: Add OpenGL support This uses EGL to implement GdkGLContext for wayland.
2014-10-09 09:06:48 +00:00
return GDK_GL_CONTEXT (context);
}
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);
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
GdkWaylandDisplay *display_wayland = GDK_WAYLAND_DISPLAY (display);
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)
eglMakeCurrent(display_wayland->egl_display, EGL_NO_SURFACE, EGL_NO_SURFACE,
EGL_NO_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
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
eglDestroyContext (display_wayland->egl_display,
context_wayland->egl_context);
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
}
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
gboolean
wayland: Add OpenGL support This uses EGL to implement GdkGLContext for wayland.
2014-10-09 09:06:48 +00:00
gdk_wayland_display_make_gl_context_current (GdkDisplay *display,
GdkGLContext *context)
{
GdkWaylandDisplay *display_wayland = GDK_WAYLAND_DISPLAY (display);
GdkWaylandGLContext *context_wayland;
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;
wayland: Add OpenGL support This uses EGL to implement GdkGLContext for wayland.
2014-10-09 09:06:48 +00:00
EGLSurface egl_surface;
if (context == NULL)
{
eglMakeCurrent(display_wayland->egl_display, EGL_NO_SURFACE, EGL_NO_SURFACE,
EGL_NO_CONTEXT);
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
return TRUE;
wayland: Add OpenGL support This uses EGL to implement GdkGLContext for wayland.
2014-10-09 09:06:48 +00:00
}
context_wayland = GDK_WAYLAND_GL_CONTEXT (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
surface = gdk_gl_context_get_surface (context);
wayland: Add OpenGL support This uses EGL to implement GdkGLContext for wayland.
2014-10-09 09:06:48 +00:00
drawcontext: Add gdk_draw_context_in_frame() API This makes the previous gdk_draw_context_is_drawing() function public under a new name. I decided against the old name because we use the term "frame" for a drawing operation, so I wanted to have this boolean flag reuse the term.
2018-04-23 16:24:29 +00:00
if (context_wayland->is_attached || gdk_draw_context_is_in_frame (GDK_DRAW_CONTEXT (context)))
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
egl_surface = gdk_wayland_surface_get_egl_surface (surface, context_wayland->egl_config);
gl: Make all user GdkGLContexts not attached to any window We make user facing gl contexts not attached to a surface if possible, or attached to dummy surfaces. This means nothing can accidentally read/write to the toplevel back buffer.
2014-10-09 14:09:05 +00:00
else
{
if (display_wayland->have_egl_surfaceless_context)
egl_surface = EGL_NO_SURFACE;
else
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
egl_surface = gdk_wayland_surface_get_dummy_egl_surface (surface,
gl: Make all user GdkGLContexts not attached to any window We make user facing gl contexts not attached to a surface if possible, or attached to dummy surfaces. This means nothing can accidentally read/write to the toplevel back buffer.
2014-10-09 14:09:05 +00:00
context_wayland->egl_config);
}
wayland: Add OpenGL support This uses EGL to implement GdkGLContext for wayland.
2014-10-09 09:06:48 +00:00
gl: Make gdk_gl_context_make_current() return void Its not really reasonable to handle failures to make_current, it basically only happens if you pass invalid arguments to it, and thats not something we trap on similar things on the X drawing side. If GL is not supported that should be handled by the context creation failing, and anything going wrong after that is essentially a critical (or an async X error).
2014-10-09 15:24:21 +00:00
if (!eglMakeCurrent (display_wayland->egl_display, egl_surface,
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
egl_surface, context_wayland->egl_context))
{
g_warning ("eglMakeCurrent failed");
return FALSE;
}
return TRUE;
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