AuroraMiddleware/gtk
1
0
Fork 1
mirror of https://gitlab.gnome.org/GNOME/gtk.git synced 2024-12-27 06:00:22 +00:00
Code Issues Projects Releases Wiki Activity
c5973a630b
gtk/gdk/x11/gdkglcontext-glx.c

1020 lines
34 KiB
C
Raw Normal View History

x11: Decouple GLX from GdkX11GLContext If we want to add an EGL implementation for the X11 backend, we are going to need to move the GLX bits into their own class. The first step is to declare GdkX11GLContext as an abstract type, and then subclass it into a GdkX11GLContextGLX type, which includes the whole GLX implementation.
2021-05-10 14:07:08 +00:00
/* GDK - The GIMP Drawing Kit
*
* gdkglcontext-glx.c: GLX specific wrappers
*
* SPDX-FileCopyrightText: 2014 Emmanuele Bassi
* SPDX-FileCopyrightText: 2021 GNOME Foundation
*
* SPDX-License-Identifier: LGPL-2.1-or-later
*/
#include "config.h"
#include "gdkglcontext-x11.h"
#include "gdkdisplay-x11.h"
#include "gdkprivate-x11.h"
#include "gdkscreen-x11.h"
#include "gdkx11display.h"
#include "gdkx11glcontext.h"
#include "gdkx11screen.h"
#include "gdkx11surface.h"
#include "gdkx11property.h"
#include <X11/Xatom.h>
x11: Add profiler marks for SwapBuffers
2021-05-10 17:22:34 +00:00
#include "gdkprofilerprivate.h"
x11: Decouple GLX from GdkX11GLContext If we want to add an EGL implementation for the X11 backend, we are going to need to move the GLX bits into their own class. The first step is to declare GdkX11GLContext as an abstract type, and then subclass it into a GdkX11GLContextGLX type, which includes the whole GLX implementation.
2021-05-10 14:07:08 +00:00
#include "gdkintl.h"
#include <cairo-xlib.h>
#include <epoxy/glx.h>
struct _GdkX11GLContextGLX
{
GdkX11GLContext parent_instance;
GLXContext glx_context;
x11: Move the damage fences into the GLX code It's GLX-specific anyway, there's no need to complicate things by having half the code in the generic path, and half in the GLX one.
2021-05-10 19:33:02 +00:00
#ifdef HAVE_XDAMAGE
GLsync frame_fence;
Damage xdamage;
#endif
x11: Move code from GdkGLContextX11 It's not used there, but both backends have independent immplementationgs for it. I want to get rid of GdkGLContextX11 and moving code from it is the first step.
2021-07-13 03:04:45 +00:00
guint do_frame_sync : 1;
x11: Decouple GLX from GdkX11GLContext If we want to add an EGL implementation for the X11 backend, we are going to need to move the GLX bits into their own class. The first step is to declare GdkX11GLContext as an abstract type, and then subclass it into a GdkX11GLContextGLX type, which includes the whole GLX implementation.
2021-05-10 14:07:08 +00:00
};
typedef struct _GdkX11GLContextClass GdkX11GLContextGLXClass;
G_DEFINE_TYPE (GdkX11GLContextGLX, gdk_x11_gl_context_glx, GDK_TYPE_X11_GL_CONTEXT)
x11: Store the GLX drawable in the surface Also, stop using a dummy window for unattached GL contexts and instead use the display's leader surface. Again, this mirrors EGL.
2021-06-29 21:45:50 +00:00
static GLXDrawable
gdk_x11_surface_get_glx_drawable (GdkSurface *surface)
x11: Decouple GLX from GdkX11GLContext If we want to add an EGL implementation for the X11 backend, we are going to need to move the GLX bits into their own class. The first step is to declare GdkX11GLContext as an abstract type, and then subclass it into a GdkX11GLContextGLX type, which includes the whole GLX implementation.
2021-05-10 14:07:08 +00:00
{
x11: Store the GLX drawable in the surface Also, stop using a dummy window for unattached GL contexts and instead use the display's leader surface. Again, this mirrors EGL.
2021-06-29 21:45:50 +00:00
GdkX11Surface *self = GDK_X11_SURFACE (surface);
GdkDisplay *display = gdk_surface_get_display (GDK_SURFACE (self));
GdkX11Display *display_x11 = GDK_X11_DISPLAY (display);
x11: Decouple GLX from GdkX11GLContext If we want to add an EGL implementation for the X11 backend, we are going to need to move the GLX bits into their own class. The first step is to declare GdkX11GLContext as an abstract type, and then subclass it into a GdkX11GLContextGLX type, which includes the whole GLX implementation.
2021-05-10 14:07:08 +00:00
x11: Store the GLX drawable in the surface Also, stop using a dummy window for unattached GL contexts and instead use the display's leader surface. Again, this mirrors EGL.
2021-06-29 21:45:50 +00:00
if (self->glx_drawable)
return self->glx_drawable;
x11: Decouple GLX from GdkX11GLContext If we want to add an EGL implementation for the X11 backend, we are going to need to move the GLX bits into their own class. The first step is to declare GdkX11GLContext as an abstract type, and then subclass it into a GdkX11GLContextGLX type, which includes the whole GLX implementation.
2021-05-10 14:07:08 +00:00
x11: Store the GLX drawable in the surface Also, stop using a dummy window for unattached GL contexts and instead use the display's leader surface. Again, this mirrors EGL.
2021-06-29 21:45:50 +00:00
self->glx_drawable = glXCreateWindow (gdk_x11_display_get_xdisplay (display),
display_x11->glx_config,
gdk_x11_surface_get_xid (surface),
NULL);
x11: Decouple GLX from GdkX11GLContext If we want to add an EGL implementation for the X11 backend, we are going to need to move the GLX bits into their own class. The first step is to declare GdkX11GLContext as an abstract type, and then subclass it into a GdkX11GLContextGLX type, which includes the whole GLX implementation.
2021-05-10 14:07:08 +00:00
x11: Store the GLX drawable in the surface Also, stop using a dummy window for unattached GL contexts and instead use the display's leader surface. Again, this mirrors EGL.
2021-06-29 21:45:50 +00:00
return self->glx_drawable;
}
x11: Decouple GLX from GdkX11GLContext If we want to add an EGL implementation for the X11 backend, we are going to need to move the GLX bits into their own class. The first step is to declare GdkX11GLContext as an abstract type, and then subclass it into a GdkX11GLContextGLX type, which includes the whole GLX implementation.
2021-05-10 14:07:08 +00:00
x11: Store the GLX drawable in the surface Also, stop using a dummy window for unattached GL contexts and instead use the display's leader surface. Again, this mirrors EGL.
2021-06-29 21:45:50 +00:00
void
gdk_x11_surface_destroy_glx_drawable (GdkX11Surface *self)
{
if (self->glx_drawable == None)
return;
x11: Decouple GLX from GdkX11GLContext If we want to add an EGL implementation for the X11 backend, we are going to need to move the GLX bits into their own class. The first step is to declare GdkX11GLContext as an abstract type, and then subclass it into a GdkX11GLContextGLX type, which includes the whole GLX implementation.
2021-05-10 14:07:08 +00:00
x11: Store the GLX drawable in the surface Also, stop using a dummy window for unattached GL contexts and instead use the display's leader surface. Again, this mirrors EGL.
2021-06-29 21:45:50 +00:00
glXDestroyWindow (gdk_x11_display_get_xdisplay (gdk_surface_get_display (GDK_SURFACE (self))),
self->glx_drawable);
x11: Decouple GLX from GdkX11GLContext If we want to add an EGL implementation for the X11 backend, we are going to need to move the GLX bits into their own class. The first step is to declare GdkX11GLContext as an abstract type, and then subclass it into a GdkX11GLContextGLX type, which includes the whole GLX implementation.
2021-05-10 14:07:08 +00:00
x11: Store the GLX drawable in the surface Also, stop using a dummy window for unattached GL contexts and instead use the display's leader surface. Again, this mirrors EGL.
2021-06-29 21:45:50 +00:00
self->glx_drawable = None;
}
x11: Decouple GLX from GdkX11GLContext If we want to add an EGL implementation for the X11 backend, we are going to need to move the GLX bits into their own class. The first step is to declare GdkX11GLContext as an abstract type, and then subclass it into a GdkX11GLContextGLX type, which includes the whole GLX implementation.
2021-05-10 14:07:08 +00:00
static void
maybe_wait_for_vblank (GdkDisplay *display,
GLXDrawable drawable)
{
GdkX11Display *display_x11 = GDK_X11_DISPLAY (display);
Display *dpy = gdk_x11_display_get_xdisplay (display);
if (display_x11->has_glx_sync_control)
{
gint64 ust, msc, sbc;
glXGetSyncValuesOML (dpy, drawable, &ust, &msc, &sbc);
glXWaitForMscOML (dpy, drawable,
0, 2, (msc + 1) % 2,
&ust, &msc, &sbc);
}
else if (display_x11->has_glx_video_sync)
{
guint32 current_count;
glXGetVideoSyncSGI (&current_count);
glXWaitVideoSyncSGI (2, (current_count + 1) % 2, &current_count);
}
}
x11: Store the GLX drawable in the surface Also, stop using a dummy window for unattached GL contexts and instead use the display's leader surface. Again, this mirrors EGL.
2021-06-29 21:45:50 +00:00
static GLXDrawable
gdk_x11_gl_context_glx_get_drawable (GdkX11GLContextGLX *self)
{
GdkDrawContext *draw_context = GDK_DRAW_CONTEXT (self);
GdkSurface *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
if (gdk_draw_context_is_in_frame (draw_context))
x11: Store the GLX drawable in the surface Also, stop using a dummy window for unattached GL contexts and instead use the display's leader surface. Again, this mirrors EGL.
2021-06-29 21:45:50 +00:00
surface = gdk_draw_context_get_surface (draw_context);
else
surface = GDK_X11_DISPLAY (gdk_draw_context_get_display (draw_context))->leader_gdk_surface;
return gdk_x11_surface_get_glx_drawable (surface);
}
x11: Decouple GLX from GdkX11GLContext If we want to add an EGL implementation for the X11 backend, we are going to need to move the GLX bits into their own class. The first step is to declare GdkX11GLContext as an abstract type, and then subclass it into a GdkX11GLContextGLX type, which includes the whole GLX implementation.
2021-05-10 14:07:08 +00:00
static void
gdk_x11_gl_context_glx_end_frame (GdkDrawContext *draw_context,
cairo_region_t *painted)
{
x11: Move code from GdkGLContextX11 It's not used there, but both backends have independent immplementationgs for it. I want to get rid of GdkGLContextX11 and moving code from it is the first step.
2021-07-13 03:04:45 +00:00
GdkX11GLContextGLX *self = GDK_X11_GL_CONTEXT_GLX (draw_context);
x11: Decouple GLX from GdkX11GLContext If we want to add an EGL implementation for the X11 backend, we are going to need to move the GLX bits into their own class. The first step is to declare GdkX11GLContext as an abstract type, and then subclass it into a GdkX11GLContextGLX type, which includes the whole GLX implementation.
2021-05-10 14:07:08 +00:00
GdkGLContext *context = GDK_GL_CONTEXT (draw_context);
GdkSurface *surface = gdk_gl_context_get_surface (context);
glx: Get rid fo DrawableInfo Store the frame counter in the surface, where it belongs.
2021-07-22 14:23:06 +00:00
GdkX11Surface *x11_surface = GDK_X11_SURFACE (surface);
x11: Decouple GLX from GdkX11GLContext If we want to add an EGL implementation for the X11 backend, we are going to need to move the GLX bits into their own class. The first step is to declare GdkX11GLContext as an abstract type, and then subclass it into a GdkX11GLContextGLX type, which includes the whole GLX implementation.
2021-05-10 14:07:08 +00:00
GdkDisplay *display = gdk_gl_context_get_display (context);
Display *dpy = gdk_x11_display_get_xdisplay (display);
GdkX11Display *display_x11 = GDK_X11_DISPLAY (display);
GLXDrawable drawable;
GDK_DRAW_CONTEXT_CLASS (gdk_x11_gl_context_glx_parent_class)->end_frame (draw_context, painted);
gdk_gl_context_make_current (context);
x11: Store the GLX drawable in the surface Also, stop using a dummy window for unattached GL contexts and instead use the display's leader surface. Again, this mirrors EGL.
2021-06-29 21:45:50 +00:00
drawable = gdk_x11_surface_get_glx_drawable (surface);
x11: Decouple GLX from GdkX11GLContext If we want to add an EGL implementation for the X11 backend, we are going to need to move the GLX bits into their own class. The first step is to declare GdkX11GLContext as an abstract type, and then subclass it into a GdkX11GLContextGLX type, which includes the whole GLX implementation.
2021-05-10 14:07:08 +00:00
GDK_DISPLAY_NOTE (display, OPENGL,
g_message ("Flushing GLX buffers for drawable %lu (window: %lu), frame sync: %s",
(unsigned long) drawable,
(unsigned long) gdk_x11_surface_get_xid (surface),
x11: Move code from GdkGLContextX11 It's not used there, but both backends have independent immplementationgs for it. I want to get rid of GdkGLContextX11 and moving code from it is the first step.
2021-07-13 03:04:45 +00:00
self->do_frame_sync ? "yes" : "no"));
x11: Decouple GLX from GdkX11GLContext If we want to add an EGL implementation for the X11 backend, we are going to need to move the GLX bits into their own class. The first step is to declare GdkX11GLContext as an abstract type, and then subclass it into a GdkX11GLContextGLX type, which includes the whole GLX implementation.
2021-05-10 14:07:08 +00:00
x11: Add profiler marks for SwapBuffers
2021-05-10 17:22:34 +00:00
gdk_profiler_add_mark (GDK_PROFILER_CURRENT_TIME, 0, "x11", "swap buffers");
x11: Decouple GLX from GdkX11GLContext If we want to add an EGL implementation for the X11 backend, we are going to need to move the GLX bits into their own class. The first step is to declare GdkX11GLContext as an abstract type, and then subclass it into a GdkX11GLContextGLX type, which includes the whole GLX implementation.
2021-05-10 14:07:08 +00:00
/* if we are going to wait for the vertical refresh manually
* we need to flush pending redraws, and we also need to wait
* for that to finish, otherwise we are going to tear.
*
* obviously, this condition should not be hit if we have
* GLX_SGI_swap_control, and we ask the driver to do the right
* thing.
*/
x11: Move code from GdkGLContextX11 It's not used there, but both backends have independent immplementationgs for it. I want to get rid of GdkGLContextX11 and moving code from it is the first step.
2021-07-13 03:04:45 +00:00
if (self->do_frame_sync)
x11: Decouple GLX from GdkX11GLContext If we want to add an EGL implementation for the X11 backend, we are going to need to move the GLX bits into their own class. The first step is to declare GdkX11GLContext as an abstract type, and then subclass it into a GdkX11GLContextGLX type, which includes the whole GLX implementation.
2021-05-10 14:07:08 +00:00
{
guint32 end_frame_counter = 0;
gboolean has_counter = display_x11->has_glx_video_sync;
gboolean can_wait = display_x11->has_glx_video_sync || display_x11->has_glx_sync_control;
if (display_x11->has_glx_video_sync)
glXGetVideoSyncSGI (&end_frame_counter);
x11: Move code from GdkGLContextX11 It's not used there, but both backends have independent immplementationgs for it. I want to get rid of GdkGLContextX11 and moving code from it is the first step.
2021-07-13 03:04:45 +00:00
if (self->do_frame_sync && !display_x11->has_glx_swap_interval)
x11: Decouple GLX from GdkX11GLContext If we want to add an EGL implementation for the X11 backend, we are going to need to move the GLX bits into their own class. The first step is to declare GdkX11GLContext as an abstract type, and then subclass it into a GdkX11GLContextGLX type, which includes the whole GLX implementation.
2021-05-10 14:07:08 +00:00
{
glFinish ();
if (has_counter && can_wait)
{
glx: Get rid fo DrawableInfo Store the frame counter in the surface, where it belongs.
2021-07-22 14:23:06 +00:00
if (x11_surface->glx_frame_counter == end_frame_counter)
x11: Decouple GLX from GdkX11GLContext If we want to add an EGL implementation for the X11 backend, we are going to need to move the GLX bits into their own class. The first step is to declare GdkX11GLContext as an abstract type, and then subclass it into a GdkX11GLContextGLX type, which includes the whole GLX implementation.
2021-05-10 14:07:08 +00:00
maybe_wait_for_vblank (display, drawable);
}
else if (can_wait)
maybe_wait_for_vblank (display, drawable);
}
}
gdk_x11_surface_pre_damage (surface);
#ifdef HAVE_XDAMAGE
x11: Move code from GdkGLContextX11 It's not used there, but both backends have independent immplementationgs for it. I want to get rid of GdkGLContextX11 and moving code from it is the first step.
2021-07-13 03:04:45 +00:00
if (self->xdamage != 0 && _gdk_x11_surface_syncs_frames (surface))
x11: Decouple GLX from GdkX11GLContext If we want to add an EGL implementation for the X11 backend, we are going to need to move the GLX bits into their own class. The first step is to declare GdkX11GLContext as an abstract type, and then subclass it into a GdkX11GLContextGLX type, which includes the whole GLX implementation.
2021-05-10 14:07:08 +00:00
{
x11: Move code from GdkGLContextX11 It's not used there, but both backends have independent immplementationgs for it. I want to get rid of GdkGLContextX11 and moving code from it is the first step.
2021-07-13 03:04:45 +00:00
g_assert (self->frame_fence == 0);
x11: Decouple GLX from GdkX11GLContext If we want to add an EGL implementation for the X11 backend, we are going to need to move the GLX bits into their own class. The first step is to declare GdkX11GLContext as an abstract type, and then subclass it into a GdkX11GLContextGLX type, which includes the whole GLX implementation.
2021-05-10 14:07:08 +00:00
x11: Move code from GdkGLContextX11 It's not used there, but both backends have independent immplementationgs for it. I want to get rid of GdkGLContextX11 and moving code from it is the first step.
2021-07-13 03:04:45 +00:00
self->frame_fence = glFenceSync (GL_SYNC_GPU_COMMANDS_COMPLETE, 0);
x11: Decouple GLX from GdkX11GLContext If we want to add an EGL implementation for the X11 backend, we are going to need to move the GLX bits into their own class. The first step is to declare GdkX11GLContext as an abstract type, and then subclass it into a GdkX11GLContextGLX type, which includes the whole GLX implementation.
2021-05-10 14:07:08 +00:00
/* We consider the frame still getting painted until the GL operation is
* finished, and the window gets damage reported from the X server.
* It's only at this point the compositor can be sure it has full
* access to the new updates.
*/
_gdk_x11_surface_set_frame_still_painting (surface, TRUE);
}
#endif
glXSwapBuffers (dpy, drawable);
glx: Get rid fo DrawableInfo Store the frame counter in the surface, where it belongs.
2021-07-22 14:23:06 +00:00
if (self->do_frame_sync && display_x11->has_glx_video_sync)
glXGetVideoSyncSGI (&x11_surface->glx_frame_counter);
x11: Decouple GLX from GdkX11GLContext If we want to add an EGL implementation for the X11 backend, we are going to need to move the GLX bits into their own class. The first step is to declare GdkX11GLContext as an abstract type, and then subclass it into a GdkX11GLContextGLX type, which includes the whole GLX implementation.
2021-05-10 14:07:08 +00:00
}
gl: Move vfunc Instead of Display::make_gl_context_current() we now have GLContext::clear_current() GLContext::make_current() This fits better with the backends (we can actually implement clearCurrent on macOS now) and makes it easier to implement different GL backends for backends (like EGL/GLX on X11). We also pass a surfaceless boolean to make_current() so the calling code can decide if a surface needs to be bound or not, because the backends were all doing whatever, which was very counterproductive.
2021-07-07 02:40:34 +00:00
static gboolean
gdk_x11_gl_context_glx_clear_current (GdkGLContext *context)
{
GdkDisplay *display = gdk_gl_context_get_display (context);
Display *dpy = gdk_x11_display_get_xdisplay (display);
glXMakeContextCurrent (dpy, None, None, NULL);
return TRUE;
}
static gboolean
gdk_x11_gl_context_glx_make_current (GdkGLContext *context,
gboolean surfaceless)
{
x11: Move code from GdkGLContextX11 It's not used there, but both backends have independent immplementationgs for it. I want to get rid of GdkGLContextX11 and moving code from it is the first step.
2021-07-13 03:04:45 +00:00
GdkX11GLContextGLX *self = GDK_X11_GL_CONTEXT_GLX (context);
gl: Move vfunc Instead of Display::make_gl_context_current() we now have GLContext::clear_current() GLContext::make_current() This fits better with the backends (we can actually implement clearCurrent on macOS now) and makes it easier to implement different GL backends for backends (like EGL/GLX on X11). We also pass a surfaceless boolean to make_current() so the calling code can decide if a surface needs to be bound or not, because the backends were all doing whatever, which was very counterproductive.
2021-07-07 02:40:34 +00:00
GdkDisplay *display = gdk_gl_context_get_display (context);
Display *dpy = gdk_x11_display_get_xdisplay (display);
gboolean do_frame_sync = FALSE;
GdkSurface *surface;
GLXWindow drawable;
if (!surfaceless)
surface = gdk_gl_context_get_surface (context);
else
surface = GDK_X11_DISPLAY (display)->leader_gdk_surface;
drawable = gdk_x11_surface_get_glx_drawable (surface);
GDK_DISPLAY_NOTE (display, OPENGL,
g_message ("Making GLX context %p current to drawable %lu",
context, (unsigned long) drawable));
x11: Move code from GdkGLContextX11 It's not used there, but both backends have independent immplementationgs for it. I want to get rid of GdkGLContextX11 and moving code from it is the first step.
2021-07-13 03:04:45 +00:00
if (!glXMakeContextCurrent (dpy, drawable, drawable, self->glx_context))
gl: Move vfunc Instead of Display::make_gl_context_current() we now have GLContext::clear_current() GLContext::make_current() This fits better with the backends (we can actually implement clearCurrent on macOS now) and makes it easier to implement different GL backends for backends (like EGL/GLX on X11). We also pass a surfaceless boolean to make_current() so the calling code can decide if a surface needs to be bound or not, because the backends were all doing whatever, which was very counterproductive.
2021-07-07 02:40:34 +00:00
return FALSE;
if (!surfaceless && GDK_X11_DISPLAY (display)->has_glx_swap_interval)
{
/* If the WM is compositing there is no particular need to delay
* the swap when drawing on the offscreen, rendering to the screen
* happens later anyway, and its up to the compositor to sync that
* to the vblank. */
do_frame_sync = ! gdk_display_is_composited (display);
x11: Move code from GdkGLContextX11 It's not used there, but both backends have independent immplementationgs for it. I want to get rid of GdkGLContextX11 and moving code from it is the first step.
2021-07-13 03:04:45 +00:00
if (do_frame_sync != self->do_frame_sync)
gl: Move vfunc Instead of Display::make_gl_context_current() we now have GLContext::clear_current() GLContext::make_current() This fits better with the backends (we can actually implement clearCurrent on macOS now) and makes it easier to implement different GL backends for backends (like EGL/GLX on X11). We also pass a surfaceless boolean to make_current() so the calling code can decide if a surface needs to be bound or not, because the backends were all doing whatever, which was very counterproductive.
2021-07-07 02:40:34 +00:00
{
x11: Move code from GdkGLContextX11 It's not used there, but both backends have independent immplementationgs for it. I want to get rid of GdkGLContextX11 and moving code from it is the first step.
2021-07-13 03:04:45 +00:00
self->do_frame_sync = do_frame_sync;
gl: Move vfunc Instead of Display::make_gl_context_current() we now have GLContext::clear_current() GLContext::make_current() This fits better with the backends (we can actually implement clearCurrent on macOS now) and makes it easier to implement different GL backends for backends (like EGL/GLX on X11). We also pass a surfaceless boolean to make_current() so the calling code can decide if a surface needs to be bound or not, because the backends were all doing whatever, which was very counterproductive.
2021-07-07 02:40:34 +00:00
if (do_frame_sync)
glXSwapIntervalSGI (1);
else
glXSwapIntervalSGI (0);
}
}
return TRUE;
}
x11: Decouple GLX from GdkX11GLContext If we want to add an EGL implementation for the X11 backend, we are going to need to move the GLX bits into their own class. The first step is to declare GdkX11GLContext as an abstract type, and then subclass it into a GdkX11GLContextGLX type, which includes the whole GLX implementation.
2021-05-10 14:07:08 +00:00
static cairo_region_t *
gdk_x11_gl_context_glx_get_damage (GdkGLContext *context)
{
GdkDisplay *display = gdk_draw_context_get_display (GDK_DRAW_CONTEXT (context));
GdkX11Display *display_x11 = GDK_X11_DISPLAY (display);
Display *dpy = gdk_x11_display_get_xdisplay (display);
unsigned int buffer_age = 0;
if (display_x11->has_glx_buffer_age)
{
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
GdkX11GLContextGLX *self = GDK_X11_GL_CONTEXT_GLX (context);
x11: Decouple GLX from GdkX11GLContext If we want to add an EGL implementation for the X11 backend, we are going to need to move the GLX bits into their own class. The first step is to declare GdkX11GLContext as an abstract type, and then subclass it into a GdkX11GLContextGLX type, which includes the whole GLX implementation.
2021-05-10 14:07:08 +00:00
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);
glXQueryDrawable (dpy, gdk_x11_gl_context_glx_get_drawable (self),
x11: Decouple GLX from GdkX11GLContext If we want to add an EGL implementation for the X11 backend, we are going to need to move the GLX bits into their own class. The first step is to declare GdkX11GLContext as an abstract type, and then subclass it into a GdkX11GLContextGLX type, which includes the whole GLX implementation.
2021-05-10 14:07:08 +00:00
GLX_BACK_BUFFER_AGE_EXT, &buffer_age);
switch (buffer_age)
{
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:
;
}
}
return GDK_GL_CONTEXT_CLASS (gdk_x11_gl_context_glx_parent_class)->get_damage (context);
}
static GLXContext
create_gl3_context (GdkDisplay *display,
GLXFBConfig config,
GdkGLContext *share,
int profile,
int flags,
int major,
int minor)
{
int attrib_list[] = {
GLX_CONTEXT_PROFILE_MASK_ARB, profile,
GLX_CONTEXT_MAJOR_VERSION_ARB, major,
GLX_CONTEXT_MINOR_VERSION_ARB, minor,
GLX_CONTEXT_FLAGS_ARB, flags,
None,
};
GLXContext res;
GdkX11GLContextGLX *share_glx = NULL;
if (share != NULL)
share_glx = GDK_X11_GL_CONTEXT_GLX (share);
gdk_x11_display_error_trap_push (display);
res = glXCreateContextAttribsARB (gdk_x11_display_get_xdisplay (display),
config,
share_glx != NULL ? share_glx->glx_context : NULL,
True,
attrib_list);
if (gdk_x11_display_error_trap_pop (display))
return NULL;
return res;
}
static GLXContext
create_legacy_context (GdkDisplay *display,
GLXFBConfig config,
GdkGLContext *share)
{
GdkX11GLContextGLX *share_glx = NULL;
GLXContext res;
if (share != NULL)
share_glx = GDK_X11_GL_CONTEXT_GLX (share);
gdk_x11_display_error_trap_push (display);
res = glXCreateNewContext (gdk_x11_display_get_xdisplay (display),
config,
GLX_RGBA_TYPE,
share_glx != NULL ? share_glx->glx_context : NULL,
TRUE);
if (gdk_x11_display_error_trap_pop (display))
return NULL;
return res;
}
x11: Move the damage fences into the GLX code It's GLX-specific anyway, there's no need to complicate things by having half the code in the generic path, and half in the GLX one.
2021-05-10 19:33:02 +00:00
#ifdef HAVE_XDAMAGE
static void
bind_context_for_frame_fence (GdkX11GLContextGLX *self)
{
GdkX11GLContextGLX *current_context_glx;
GLXContext current_glx_context = NULL;
GdkGLContext *current_context;
gboolean needs_binding = TRUE;
/* We don't care if the passed context is the current context,
* necessarily, but we do care that *some* context that can
* see the sync object is bound.
*
* If no context is bound at all, the GL dispatch layer will
* make glClientWaitSync() silently return 0.
*/
current_glx_context = glXGetCurrentContext ();
if (current_glx_context == NULL)
goto out;
current_context = gdk_gl_context_get_current ();
if (current_context == NULL)
goto out;
current_context_glx = GDK_X11_GL_CONTEXT_GLX (current_context);
/* If the GLX context was changed out from under GDK, then
* that context may not be one that is able to see the
* created fence object.
*/
if (current_context_glx->glx_context != current_glx_context)
goto out;
needs_binding = FALSE;
out:
if (needs_binding)
gdk_gl_context_make_current (GDK_GL_CONTEXT (self));
}
static void
finish_frame (GdkGLContext *context)
{
GdkX11GLContextGLX *context_glx = GDK_X11_GL_CONTEXT_GLX (context);
GdkSurface *surface = gdk_gl_context_get_surface (context);
if (context_glx->xdamage == 0)
return;
if (context_glx->frame_fence == 0)
return;
glDeleteSync (context_glx->frame_fence);
context_glx->frame_fence = 0;
_gdk_x11_surface_set_frame_still_painting (surface, FALSE);
}
static gboolean
on_gl_surface_xevent (GdkGLContext *context,
XEvent *xevent,
GdkX11Display *display_x11)
{
GdkX11GLContextGLX *context_glx = GDK_X11_GL_CONTEXT_GLX (context);
XDamageNotifyEvent *damage_xevent;
if (xevent->type != (display_x11->damage_event_base + XDamageNotify))
return FALSE;
damage_xevent = (XDamageNotifyEvent *) xevent;
if (damage_xevent->damage != context_glx->xdamage)
return FALSE;
if (context_glx->frame_fence)
{
GLenum wait_result;
bind_context_for_frame_fence (context_glx);
wait_result = glClientWaitSync (context_glx->frame_fence, 0, 0);
switch (wait_result)
{
/* We assume that if the fence has been signaled, that this damage
* event is the damage event that was triggered by the GL drawing
* associated with the fence. That's, technically, not necessarly
* always true. The X server could have generated damage for
* an unrelated event (say the size of the window changing), at
* just the right moment such that we're picking it up instead.
*
* We're choosing not to handle this edge case, but if it does ever
* happen in the wild, it could lead to slight underdrawing by
* the compositor for one frame. In the future, if we find out
* this edge case is noticeable, we can compensate by copying the
* painted region from gdk_x11_gl_context_end_frame and subtracting
* damaged areas from the copy as they come in. Once the copied
* region goes empty, we know that there won't be any underdraw,
* and can mark painting has finished. It's not worth the added
* complexity and resource usage to do this bookkeeping, however,
* unless the problem is practically visible.
*/
case GL_ALREADY_SIGNALED:
case GL_CONDITION_SATISFIED:
case GL_WAIT_FAILED:
if (wait_result == GL_WAIT_FAILED)
g_warning ("failed to wait on GL fence associated with last swap buffers call");
finish_frame (context);
break;
/* We assume that if the fence hasn't been signaled, that this
* damage event is not the damage event that was triggered by the
* GL drawing associated with the fence. That's only true for
* the Nvidia vendor driver. When using open source drivers, damage
* is emitted immediately on swap buffers, before the fence ever
* has a chance to signal.
*/
case GL_TIMEOUT_EXPIRED:
break;
default:
g_error ("glClientWaitSync returned unexpected result: %x", (guint) wait_result);
}
}
return FALSE;
}
static void
on_surface_state_changed (GdkGLContext *context)
{
GdkSurface *surface = gdk_gl_context_get_surface (context);
if (GDK_SURFACE_IS_MAPPED (surface))
return;
/* If we're about to withdraw the surface, then we don't care if the frame is
* still getting rendered by the GPU. The compositor is going to remove the surface
* from the scene anyway, so wrap up the frame.
*/
finish_frame (context);
}
#endif
gl: Check allowed APIs in realize() Add gdk_gl_context_is_api_allowed() for backends and make them use it. Finally, have them return the final API as the return value (or 0 on error). And then use that api instead of a use_es boolean flag. Fixes #4221
2021-10-07 20:10:39 +00:00
static GdkGLAPI
x11: Decouple GLX from GdkX11GLContext If we want to add an EGL implementation for the X11 backend, we are going to need to move the GLX bits into their own class. The first step is to declare GdkX11GLContext as an abstract type, and then subclass it into a GdkX11GLContextGLX type, which includes the whole GLX implementation.
2021-05-10 14:07:08 +00:00
gdk_x11_gl_context_glx_realize (GdkGLContext *context,
GError **error)
{
GdkX11Display *display_x11;
GdkDisplay *display;
GdkX11GLContextGLX *context_glx;
Display *dpy;
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
GdkSurface *surface;
x11: Decouple GLX from GdkX11GLContext If we want to add an EGL implementation for the X11 backend, we are going to need to move the GLX bits into their own class. The first step is to declare GdkX11GLContext as an abstract type, and then subclass it into a GdkX11GLContextGLX type, which includes the whole GLX implementation.
2021-05-10 14:07:08 +00:00
GdkGLContext *share;
gl: Check allowed APIs in realize() Add gdk_gl_context_is_api_allowed() for backends and make them use it. Finally, have them return the final API as the return value (or 0 on error). And then use that api instead of a use_es boolean flag. Fixes #4221
2021-10-07 20:10:39 +00:00
gboolean debug_bit, compat_bit, legacy_bit;
x11: Decouple GLX from GdkX11GLContext If we want to add an EGL implementation for the X11 backend, we are going to need to move the GLX bits into their own class. The first step is to declare GdkX11GLContext as an abstract type, and then subclass it into a GdkX11GLContextGLX type, which includes the whole GLX implementation.
2021-05-10 14:07:08 +00:00
int major, minor, flags;
gl: Check allowed APIs in realize() Add gdk_gl_context_is_api_allowed() for backends and make them use it. Finally, have them return the final API as the return value (or 0 on error). And then use that api instead of a use_es boolean flag. Fixes #4221
2021-10-07 20:10:39 +00:00
GdkGLAPI api = 0;
x11: Decouple GLX from GdkX11GLContext If we want to add an EGL implementation for the X11 backend, we are going to need to move the GLX bits into their own class. The first step is to declare GdkX11GLContext as an abstract type, and then subclass it into a GdkX11GLContextGLX type, which includes the whole GLX implementation.
2021-05-10 14:07:08 +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
display = gdk_gl_context_get_display (context);
x11: Decouple GLX from GdkX11GLContext If we want to add an EGL implementation for the X11 backend, we are going to need to move the GLX bits into their own class. The first step is to declare GdkX11GLContext as an abstract type, and then subclass it into a GdkX11GLContextGLX type, which includes the whole GLX implementation.
2021-05-10 14:07:08 +00:00
dpy = gdk_x11_display_get_xdisplay (display);
context_glx = GDK_X11_GL_CONTEXT_GLX (context);
display_x11 = GDK_X11_DISPLAY (display);
gdk: Add GdkDisplay::init_gl vfunc The vfunc is called to initialize GL and it returns a "base" context that GDK then uses as the context all others are shared with. So the GL context share tree now looks like: + context from init_gl - context1 - context2 ... So this is a flat tree now, the complexity is gone. The only caveat is that backends now need to create a GL context when initializing GL so some refactoring was needed. Two new functions have been added: * gdk_display_prepare_gl() This is public API and can be used to ensure that GL has been initialized or if not, retrieve an error to display (or debug-print). * gdk_display_get_gl_context() This is a private function to retrieve the base context from init_gl(). It replaces gdk_surface_get_shared_data_context().
2021-07-04 23:57:03 +00:00
share = gdk_display_get_gl_context (display);
surface = gdk_gl_context_get_surface (context);
x11: Decouple GLX from GdkX11GLContext If we want to add an EGL implementation for the X11 backend, we are going to need to move the GLX bits into their own class. The first step is to declare GdkX11GLContext as an abstract type, and then subclass it into a GdkX11GLContextGLX type, which includes the whole GLX implementation.
2021-05-10 14:07:08 +00:00
gdk_gl_context_get_required_version (context, &major, &minor);
debug_bit = gdk_gl_context_get_debug_enabled (context);
compat_bit = gdk_gl_context_get_forward_compatible (context);
/* If there is no glXCreateContextAttribsARB() then we default to legacy */
legacy_bit = !display_x11->has_glx_create_context || GDK_DISPLAY_DEBUG_CHECK (display, GL_LEGACY);
/* We cannot share legacy contexts with core profile ones, so the
* shared context is the one that decides if we're going to create
* a legacy context or not.
*/
if (share != NULL && gdk_gl_context_is_legacy (share))
legacy_bit = TRUE;
flags = 0;
if (debug_bit)
flags |= GLX_CONTEXT_DEBUG_BIT_ARB;
if (compat_bit)
flags |= GLX_CONTEXT_FORWARD_COMPATIBLE_BIT_ARB;
GDK_DISPLAY_NOTE (display, OPENGL,
gl: Check allowed APIs in realize() Add gdk_gl_context_is_api_allowed() for backends and make them use it. Finally, have them return the final API as the return value (or 0 on error). And then use that api instead of a use_es boolean flag. Fixes #4221
2021-10-07 20:10:39 +00:00
g_message ("Creating GLX context (GL version:%d.%d, debug:%s, forward:%s, legacy:%s, GL:%s, GLES:%s)",
x11: Decouple GLX from GdkX11GLContext If we want to add an EGL implementation for the X11 backend, we are going to need to move the GLX bits into their own class. The first step is to declare GdkX11GLContext as an abstract type, and then subclass it into a GdkX11GLContextGLX type, which includes the whole GLX implementation.
2021-05-10 14:07:08 +00:00
major, minor,
debug_bit ? "yes" : "no",
compat_bit ? "yes" : "no",
legacy_bit ? "yes" : "no",
gl: Check allowed APIs in realize() Add gdk_gl_context_is_api_allowed() for backends and make them use it. Finally, have them return the final API as the return value (or 0 on error). And then use that api instead of a use_es boolean flag. Fixes #4221
2021-10-07 20:10:39 +00:00
gdk_gl_context_is_api_allowed (context, GDK_GL_API_GL, NULL) ? "yes" : "no",
gdk_gl_context_is_api_allowed (context, GDK_GL_API_GLES, NULL) ? "yes" : "no"));
x11: Decouple GLX from GdkX11GLContext If we want to add an EGL implementation for the X11 backend, we are going to need to move the GLX bits into their own class. The first step is to declare GdkX11GLContext as an abstract type, and then subclass it into a GdkX11GLContextGLX type, which includes the whole GLX implementation.
2021-05-10 14:07:08 +00:00
/* If we have access to GLX_ARB_create_context_profile then we can ask for
* a compatibility profile; if we don't, then we have to fall back to the
* old GLX 1.3 API.
*/
if (legacy_bit && !GDK_X11_DISPLAY (display)->has_glx_create_context)
{
GDK_DISPLAY_NOTE (display, OPENGL, g_message ("Creating legacy GL context on request"));
gl: Check allowed APIs in realize() Add gdk_gl_context_is_api_allowed() for backends and make them use it. Finally, have them return the final API as the return value (or 0 on error). And then use that api instead of a use_es boolean flag. Fixes #4221
2021-10-07 20:10:39 +00:00
/* do it below */
x11: Decouple GLX from GdkX11GLContext If we want to add an EGL implementation for the X11 backend, we are going to need to move the GLX bits into their own class. The first step is to declare GdkX11GLContext as an abstract type, and then subclass it into a GdkX11GLContextGLX type, which includes the whole GLX implementation.
2021-05-10 14:07:08 +00:00
}
else
{
gl: Check allowed APIs in realize() Add gdk_gl_context_is_api_allowed() for backends and make them use it. Finally, have them return the final API as the return value (or 0 on error). And then use that api instead of a use_es boolean flag. Fixes #4221
2021-10-07 20:10:39 +00:00
if (gdk_gl_context_is_api_allowed (context, GDK_GL_API_GL, NULL))
{
int profile = legacy_bit ? GLX_CONTEXT_COMPATIBILITY_PROFILE_BIT_ARB
: GLX_CONTEXT_CORE_PROFILE_BIT_ARB;
x11: Decouple GLX from GdkX11GLContext If we want to add an EGL implementation for the X11 backend, we are going to need to move the GLX bits into their own class. The first step is to declare GdkX11GLContext as an abstract type, and then subclass it into a GdkX11GLContextGLX type, which includes the whole GLX implementation.
2021-05-10 14:07:08 +00:00
gl: Check allowed APIs in realize() Add gdk_gl_context_is_api_allowed() for backends and make them use it. Finally, have them return the final API as the return value (or 0 on error). And then use that api instead of a use_es boolean flag. Fixes #4221
2021-10-07 20:10:39 +00:00
/* We need to tweak the version, otherwise we may end up requesting
* a compatibility context with a minimum version of 3.2, which is
* an error
*/
if (legacy_bit)
{
major = 3;
minor = 0;
}
x11: Decouple GLX from GdkX11GLContext If we want to add an EGL implementation for the X11 backend, we are going to need to move the GLX bits into their own class. The first step is to declare GdkX11GLContext as an abstract type, and then subclass it into a GdkX11GLContextGLX type, which includes the whole GLX implementation.
2021-05-10 14:07:08 +00:00
gl: Check allowed APIs in realize() Add gdk_gl_context_is_api_allowed() for backends and make them use it. Finally, have them return the final API as the return value (or 0 on error). And then use that api instead of a use_es boolean flag. Fixes #4221
2021-10-07 20:10:39 +00:00
GDK_DISPLAY_NOTE (display, OPENGL, g_message ("Creating GL3 context"));
context_glx->glx_context = create_gl3_context (display,
display_x11->glx_config,
share,
profile,
flags, major, minor);
api = GDK_GL_API_GL;
x11: Decouple GLX from GdkX11GLContext If we want to add an EGL implementation for the X11 backend, we are going to need to move the GLX bits into their own class. The first step is to declare GdkX11GLContext as an abstract type, and then subclass it into a GdkX11GLContextGLX type, which includes the whole GLX implementation.
2021-05-10 14:07:08 +00:00
}
gl: Check allowed APIs in realize() Add gdk_gl_context_is_api_allowed() for backends and make them use it. Finally, have them return the final API as the return value (or 0 on error). And then use that api instead of a use_es boolean flag. Fixes #4221
2021-10-07 20:10:39 +00:00
if (context_glx->glx_context == NULL && !legacy_bit &&
gdk_gl_context_is_api_allowed (context, GDK_GL_API_GLES, NULL))
x11: Decouple GLX from GdkX11GLContext If we want to add an EGL implementation for the X11 backend, we are going to need to move the GLX bits into their own class. The first step is to declare GdkX11GLContext as an abstract type, and then subclass it into a GdkX11GLContextGLX type, which includes the whole GLX implementation.
2021-05-10 14:07:08 +00:00
{
gl: Check allowed APIs in realize() Add gdk_gl_context_is_api_allowed() for backends and make them use it. Finally, have them return the final API as the return value (or 0 on error). And then use that api instead of a use_es boolean flag. Fixes #4221
2021-10-07 20:10:39 +00:00
GDK_DISPLAY_NOTE (display, OPENGL, g_message ("Creating GL3 GLES context"));
context_glx->glx_context = create_gl3_context (display,
display_x11->glx_config,
share,
GLX_CONTEXT_ES2_PROFILE_BIT_EXT,
flags, major, minor);
api = GDK_GL_API_GLES;
x11: Decouple GLX from GdkX11GLContext If we want to add an EGL implementation for the X11 backend, we are going to need to move the GLX bits into their own class. The first step is to declare GdkX11GLContext as an abstract type, and then subclass it into a GdkX11GLContextGLX type, which includes the whole GLX implementation.
2021-05-10 14:07:08 +00:00
}
}
gl: Check allowed APIs in realize() Add gdk_gl_context_is_api_allowed() for backends and make them use it. Finally, have them return the final API as the return value (or 0 on error). And then use that api instead of a use_es boolean flag. Fixes #4221
2021-10-07 20:10:39 +00:00
/* Fall back to legacy in case the GL3 context creation failed */
if (context_glx->glx_context == NULL &&
gdk_gl_context_is_api_allowed (context, GDK_GL_API_GL, NULL))
{
GDK_DISPLAY_NOTE (display, OPENGL, g_message ("Creating fallback legacy context"));
context_glx->glx_context = create_legacy_context (display, display_x11->glx_config, share);
legacy_bit = TRUE;
api = GDK_GL_API_GL;
}
x11: Decouple GLX from GdkX11GLContext If we want to add an EGL implementation for the X11 backend, we are going to need to move the GLX bits into their own class. The first step is to declare GdkX11GLContext as an abstract type, and then subclass it into a GdkX11GLContextGLX type, which includes the whole GLX implementation.
2021-05-10 14:07:08 +00:00
if (context_glx->glx_context == NULL)
{
g_set_error_literal (error, GDK_GL_ERROR,
GDK_GL_ERROR_NOT_AVAILABLE,
_("Unable to create a GL context"));
gl: Check allowed APIs in realize() Add gdk_gl_context_is_api_allowed() for backends and make them use it. Finally, have them return the final API as the return value (or 0 on error). And then use that api instead of a use_es boolean flag. Fixes #4221
2021-10-07 20:10:39 +00:00
return 0;
x11: Decouple GLX from GdkX11GLContext If we want to add an EGL implementation for the X11 backend, we are going to need to move the GLX bits into their own class. The first step is to declare GdkX11GLContext as an abstract type, and then subclass it into a GdkX11GLContextGLX type, which includes the whole GLX implementation.
2021-05-10 14:07:08 +00:00
}
/* Ensure that any other context is created with a legacy bit set */
gdk_gl_context_set_is_legacy (context, legacy_bit);
GDK_DISPLAY_NOTE (display, OPENGL,
g_message ("Realized GLX context[%p], %s, version: %d.%d",
context_glx->glx_context,
x11: Remove unused struct member We don't care if the GL context is direct at all.
2021-06-29 16:44:09 +00:00
glXIsDirect (dpy, context_glx->glx_context) ? "direct" : "indirect",
x11: Decouple GLX from GdkX11GLContext If we want to add an EGL implementation for the X11 backend, we are going to need to move the GLX bits into their own class. The first step is to declare GdkX11GLContext as an abstract type, and then subclass it into a GdkX11GLContextGLX type, which includes the whole GLX implementation.
2021-05-10 14:07:08 +00:00
display_x11->glx_version / 10,
display_x11->glx_version % 10));
x11: Move the damage fences into the GLX code It's GLX-specific anyway, there's no need to complicate things by having half the code in the generic path, and half in the GLX one.
2021-05-10 19:33:02 +00:00
#ifdef HAVE_XDAMAGE
if (display_x11->have_damage &&
display_x11->has_async_glx_swap_buffers)
{
gdk_x11_display_error_trap_push (display);
context_glx->xdamage = XDamageCreate (dpy,
gdk_x11_surface_get_xid (surface),
XDamageReportRawRectangles);
if (gdk_x11_display_error_trap_pop (display))
{
context_glx->xdamage = 0;
}
else
{
g_signal_connect_object (G_OBJECT (display),
"xevent",
G_CALLBACK (on_gl_surface_xevent),
context,
G_CONNECT_SWAPPED);
g_signal_connect_object (G_OBJECT (surface),
"notify::state",
G_CALLBACK (on_surface_state_changed),
context,
G_CONNECT_SWAPPED);
}
}
#endif
gl: Check allowed APIs in realize() Add gdk_gl_context_is_api_allowed() for backends and make them use it. Finally, have them return the final API as the return value (or 0 on error). And then use that api instead of a use_es boolean flag. Fixes #4221
2021-10-07 20:10:39 +00:00
return api;
x11: Decouple GLX from GdkX11GLContext If we want to add an EGL implementation for the X11 backend, we are going to need to move the GLX bits into their own class. The first step is to declare GdkX11GLContext as an abstract type, and then subclass it into a GdkX11GLContextGLX type, which includes the whole GLX implementation.
2021-05-10 14:07:08 +00:00
}
static void
gdk_x11_gl_context_glx_dispose (GObject *gobject)
{
GdkX11GLContextGLX *context_glx = GDK_X11_GL_CONTEXT_GLX (gobject);
x11: Move the damage fences into the GLX code It's GLX-specific anyway, there's no need to complicate things by having half the code in the generic path, and half in the GLX one.
2021-05-10 19:33:02 +00:00
#ifdef HAVE_XDAMAGE
context_glx->xdamage = 0;
#endif
x11: Decouple GLX from GdkX11GLContext If we want to add an EGL implementation for the X11 backend, we are going to need to move the GLX bits into their own class. The first step is to declare GdkX11GLContext as an abstract type, and then subclass it into a GdkX11GLContextGLX type, which includes the whole GLX implementation.
2021-05-10 14:07:08 +00:00
if (context_glx->glx_context != NULL)
{
GdkGLContext *context = GDK_GL_CONTEXT (gobject);
GdkDisplay *display = gdk_gl_context_get_display (context);
Display *dpy = gdk_x11_display_get_xdisplay (display);
if (glXGetCurrentContext () == context_glx->glx_context)
glXMakeContextCurrent (dpy, None, None, NULL);
GDK_DISPLAY_NOTE (display, OPENGL, g_message ("Destroying GLX context"));
glXDestroyContext (dpy, context_glx->glx_context);
context_glx->glx_context = NULL;
}
G_OBJECT_CLASS (gdk_x11_gl_context_glx_parent_class)->dispose (gobject);
}
static void
gdk_x11_gl_context_glx_class_init (GdkX11GLContextGLXClass *klass)
{
GdkGLContextClass *context_class = GDK_GL_CONTEXT_CLASS (klass);
GdkDrawContextClass *draw_context_class = GDK_DRAW_CONTEXT_CLASS (klass);
GObjectClass *gobject_class = G_OBJECT_CLASS (klass);
gdk: Make sure only one GL backend is used Creative people managed to create an X11 display and a Wayland display at once, thereby getting EGL and GLX involved in a fight to the death over the ownership of the glFoo() symbolspace. A way to force such a fight with available tools here is (on Wayland) running something like: GTK_INSPECTOR_DISPLAY=:1 GTK_DEBUG=interactive gtk4-demo Related: xdg-desktop-portal-gnome#5
2021-09-23 23:47:03 +00:00
context_class->backend_type = GDK_GL_GLX;
x11: Decouple GLX from GdkX11GLContext If we want to add an EGL implementation for the X11 backend, we are going to need to move the GLX bits into their own class. The first step is to declare GdkX11GLContext as an abstract type, and then subclass it into a GdkX11GLContextGLX type, which includes the whole GLX implementation.
2021-05-10 14:07:08 +00:00
context_class->realize = gdk_x11_gl_context_glx_realize;
gl: Move vfunc Instead of Display::make_gl_context_current() we now have GLContext::clear_current() GLContext::make_current() This fits better with the backends (we can actually implement clearCurrent on macOS now) and makes it easier to implement different GL backends for backends (like EGL/GLX on X11). We also pass a surfaceless boolean to make_current() so the calling code can decide if a surface needs to be bound or not, because the backends were all doing whatever, which was very counterproductive.
2021-07-07 02:40:34 +00:00
context_class->make_current = gdk_x11_gl_context_glx_make_current;
context_class->clear_current = gdk_x11_gl_context_glx_clear_current;
x11: Decouple GLX from GdkX11GLContext If we want to add an EGL implementation for the X11 backend, we are going to need to move the GLX bits into their own class. The first step is to declare GdkX11GLContext as an abstract type, and then subclass it into a GdkX11GLContextGLX type, which includes the whole GLX implementation.
2021-05-10 14:07:08 +00:00
context_class->get_damage = gdk_x11_gl_context_glx_get_damage;
draw_context_class->end_frame = gdk_x11_gl_context_glx_end_frame;
gobject_class->dispose = gdk_x11_gl_context_glx_dispose;
}
static void
gdk_x11_gl_context_glx_init (GdkX11GLContextGLX *self)
{
x11: Move code from GdkGLContextX11 It's not used there, but both backends have independent immplementationgs for it. I want to get rid of GdkGLContextX11 and moving code from it is the first step.
2021-07-13 03:04:45 +00:00
self->do_frame_sync = TRUE;
x11: Decouple GLX from GdkX11GLContext If we want to add an EGL implementation for the X11 backend, we are going to need to move the GLX bits into their own class. The first step is to declare GdkX11GLContext as an abstract type, and then subclass it into a GdkX11GLContextGLX type, which includes the whole GLX implementation.
2021-05-10 14:07:08 +00:00
}
x11: Use single GLX fbconfig and store it in the display This mirrors the code for the EGL config.
2021-06-29 20:10:48 +00:00
static gboolean
visual_is_rgba (XVisualInfo *visinfo)
{
return
visinfo->depth == 32 &&
visinfo->visual->red_mask == 0xff0000 &&
visinfo->visual->green_mask == 0x00ff00 &&
visinfo->visual->blue_mask == 0x0000ff;
}
x11: Decouple GLX from GdkX11GLContext If we want to add an EGL implementation for the X11 backend, we are going to need to move the GLX bits into their own class. The first step is to declare GdkX11GLContext as an abstract type, and then subclass it into a GdkX11GLContextGLX type, which includes the whole GLX implementation.
2021-05-10 14:07:08 +00:00
#define MAX_GLX_ATTRS 30
x11: Properly record the error when initializing GL That way, we can give a useful error message when things break down for users. These error messages could still be improved in places (like looking at the actual EGL error codes), but that seemed overkill.
2021-07-02 01:21:14 +00:00
static gboolean
x11: Use single GLX fbconfig and store it in the display This mirrors the code for the EGL config.
2021-06-29 20:10:48 +00:00
gdk_x11_display_create_glx_config (GdkX11Display *self,
Visual **out_visual,
x11: Properly record the error when initializing GL That way, we can give a useful error message when things break down for users. These error messages could still be improved in places (like looking at the actual EGL error codes), but that seemed overkill.
2021-07-02 01:21:14 +00:00
int *out_depth,
GError **error)
x11: Decouple GLX from GdkX11GLContext If we want to add an EGL implementation for the X11 backend, we are going to need to move the GLX bits into their own class. The first step is to declare GdkX11GLContext as an abstract type, and then subclass it into a GdkX11GLContextGLX type, which includes the whole GLX implementation.
2021-05-10 14:07:08 +00:00
{
x11: Use single GLX fbconfig and store it in the display This mirrors the code for the EGL config.
2021-06-29 20:10:48 +00:00
GdkDisplay *display = GDK_DISPLAY (self);
x11: Decouple GLX from GdkX11GLContext If we want to add an EGL implementation for the X11 backend, we are going to need to move the GLX bits into their own class. The first step is to declare GdkX11GLContext as an abstract type, and then subclass it into a GdkX11GLContextGLX type, which includes the whole GLX implementation.
2021-05-10 14:07:08 +00:00
Display *dpy = gdk_x11_display_get_xdisplay (display);
x11: Use single GLX fbconfig and store it in the display This mirrors the code for the EGL config.
2021-06-29 20:10:48 +00:00
int attrs[MAX_GLX_ATTRS];
x11: Decouple GLX from GdkX11GLContext If we want to add an EGL implementation for the X11 backend, we are going to need to move the GLX bits into their own class. The first step is to declare GdkX11GLContext as an abstract type, and then subclass it into a GdkX11GLContextGLX type, which includes the whole GLX implementation.
2021-05-10 14:07:08 +00:00
GLXFBConfig *configs;
x11: Use single GLX fbconfig and store it in the display This mirrors the code for the EGL config.
2021-06-29 20:10:48 +00:00
int count;
enum {
NO_VISUAL_FOUND,
WITH_MULTISAMPLING,
WITH_STENCIL_AND_DEPTH_BUFFER,
NO_ALPHA,
NO_ALPHA_VISUAL,
PERFECT
} best_features;
int i = 0;
x11: Decouple GLX from GdkX11GLContext If we want to add an EGL implementation for the X11 backend, we are going to need to move the GLX bits into their own class. The first step is to declare GdkX11GLContext as an abstract type, and then subclass it into a GdkX11GLContextGLX type, which includes the whole GLX implementation.
2021-05-10 14:07:08 +00:00
attrs[i++] = GLX_DRAWABLE_TYPE;
attrs[i++] = GLX_WINDOW_BIT;
attrs[i++] = GLX_RENDER_TYPE;
attrs[i++] = GLX_RGBA_BIT;
attrs[i++] = GLX_DOUBLEBUFFER;
attrs[i++] = GL_TRUE;
attrs[i++] = GLX_RED_SIZE;
attrs[i++] = 1;
attrs[i++] = GLX_GREEN_SIZE;
attrs[i++] = 1;
attrs[i++] = GLX_BLUE_SIZE;
attrs[i++] = 1;
x11: Use single GLX fbconfig and store it in the display This mirrors the code for the EGL config.
2021-06-29 20:10:48 +00:00
attrs[i++] = GLX_ALPHA_SIZE;
attrs[i++] = 1;
x11: Decouple GLX from GdkX11GLContext If we want to add an EGL implementation for the X11 backend, we are going to need to move the GLX bits into their own class. The first step is to declare GdkX11GLContext as an abstract type, and then subclass it into a GdkX11GLContextGLX type, which includes the whole GLX implementation.
2021-05-10 14:07:08 +00:00
attrs[i++] = None;
g_assert (i < MAX_GLX_ATTRS);
x11: Use single GLX fbconfig and store it in the display This mirrors the code for the EGL config.
2021-06-29 20:10:48 +00:00
configs = glXChooseFBConfig (dpy, DefaultScreen (dpy), attrs, &count);
if (configs == NULL || count == 0)
x11: Properly record the error when initializing GL That way, we can give a useful error message when things break down for users. These error messages could still be improved in places (like looking at the actual EGL error codes), but that seemed overkill.
2021-07-02 01:21:14 +00:00
{
g_set_error_literal (error, GDK_GL_ERROR,
GDK_GL_ERROR_NOT_AVAILABLE,
_("No GLX configurations available"));
return FALSE;
}
x11: Rework Visual selection Instead of going via GdkVisual, doing a preselection and letting the GL initialization improve it, let the GL initialization pick an X Visual directly using X Visual code directly. The code should select the same visuals as before as it tries to apply the same logic, but it's a rewrite, so I expect I messed something up.
2021-06-13 15:34:55 +00:00
best_features = NO_VISUAL_FOUND;
x11: Decouple GLX from GdkX11GLContext If we want to add an EGL implementation for the X11 backend, we are going to need to move the GLX bits into their own class. The first step is to declare GdkX11GLContext as an abstract type, and then subclass it into a GdkX11GLContextGLX type, which includes the whole GLX implementation.
2021-05-10 14:07:08 +00:00
x11: Use single GLX fbconfig and store it in the display This mirrors the code for the EGL config.
2021-06-29 20:10:48 +00:00
for (i = 0; i < count; i++)
x11: Decouple GLX from GdkX11GLContext If we want to add an EGL implementation for the X11 backend, we are going to need to move the GLX bits into their own class. The first step is to declare GdkX11GLContext as an abstract type, and then subclass it into a GdkX11GLContextGLX type, which includes the whole GLX implementation.
2021-05-10 14:07:08 +00:00
{
x11: Use single GLX fbconfig and store it in the display This mirrors the code for the EGL config.
2021-06-29 20:10:48 +00:00
XVisualInfo *visinfo;
x11: Rework Visual selection Instead of going via GdkVisual, doing a preselection and letting the GL initialization improve it, let the GL initialization pick an X Visual directly using X Visual code directly. The code should select the same visuals as before as it tries to apply the same logic, but it's a rewrite, so I expect I messed something up.
2021-06-13 15:34:55 +00:00
int tmp;
x11: Decouple GLX from GdkX11GLContext If we want to add an EGL implementation for the X11 backend, we are going to need to move the GLX bits into their own class. The first step is to declare GdkX11GLContext as an abstract type, and then subclass it into a GdkX11GLContextGLX type, which includes the whole GLX implementation.
2021-05-10 14:07:08 +00:00
x11: Use single GLX fbconfig and store it in the display This mirrors the code for the EGL config.
2021-06-29 20:10:48 +00:00
visinfo = glXGetVisualFromFBConfig (dpy, configs[i]);
if (visinfo == NULL)
x11: Decouple GLX from GdkX11GLContext If we want to add an EGL implementation for the X11 backend, we are going to need to move the GLX bits into their own class. The first step is to declare GdkX11GLContext as an abstract type, and then subclass it into a GdkX11GLContextGLX type, which includes the whole GLX implementation.
2021-05-10 14:07:08 +00:00
continue;
x11: Use single GLX fbconfig and store it in the display This mirrors the code for the EGL config.
2021-06-29 20:10:48 +00:00
if (glXGetFBConfigAttrib (dpy, configs[i], GLX_SAMPLE_BUFFERS_ARB, &tmp) != Success || tmp != 0)
x11: Rework Visual selection Instead of going via GdkVisual, doing a preselection and letting the GL initialization improve it, let the GL initialization pick an X Visual directly using X Visual code directly. The code should select the same visuals as before as it tries to apply the same logic, but it's a rewrite, so I expect I messed something up.
2021-06-13 15:34:55 +00:00
{
if (best_features < WITH_MULTISAMPLING)
{
x11: Use single GLX fbconfig and store it in the display This mirrors the code for the EGL config.
2021-06-29 20:10:48 +00:00
GDK_NOTE (OPENGL, g_message ("Best GLX config is %u for visual 0x%lX with multisampling", i, visinfo->visualid));
x11: Rework Visual selection Instead of going via GdkVisual, doing a preselection and letting the GL initialization improve it, let the GL initialization pick an X Visual directly using X Visual code directly. The code should select the same visuals as before as it tries to apply the same logic, but it's a rewrite, so I expect I messed something up.
2021-06-13 15:34:55 +00:00
best_features = WITH_MULTISAMPLING;
x11: Use single GLX fbconfig and store it in the display This mirrors the code for the EGL config.
2021-06-29 20:10:48 +00:00
*out_visual = visinfo->visual;
*out_depth = visinfo->depth;
self->glx_config = configs[i];
x11: Rework Visual selection Instead of going via GdkVisual, doing a preselection and letting the GL initialization improve it, let the GL initialization pick an X Visual directly using X Visual code directly. The code should select the same visuals as before as it tries to apply the same logic, but it's a rewrite, so I expect I messed something up.
2021-06-13 15:34:55 +00:00
}
x11: Use single GLX fbconfig and store it in the display This mirrors the code for the EGL config.
2021-06-29 20:10:48 +00:00
XFree (visinfo);
x11: Rework Visual selection Instead of going via GdkVisual, doing a preselection and letting the GL initialization improve it, let the GL initialization pick an X Visual directly using X Visual code directly. The code should select the same visuals as before as it tries to apply the same logic, but it's a rewrite, so I expect I messed something up.
2021-06-13 15:34:55 +00:00
continue;
}
x11: Decouple GLX from GdkX11GLContext If we want to add an EGL implementation for the X11 backend, we are going to need to move the GLX bits into their own class. The first step is to declare GdkX11GLContext as an abstract type, and then subclass it into a GdkX11GLContextGLX type, which includes the whole GLX implementation.
2021-05-10 14:07:08 +00:00
x11: Use single GLX fbconfig and store it in the display This mirrors the code for the EGL config.
2021-06-29 20:10:48 +00:00
if (glXGetFBConfigAttrib (dpy, configs[i], GLX_DEPTH_SIZE, &tmp) != Success || tmp != 0 ||
glXGetFBConfigAttrib (dpy, configs[i], GLX_STENCIL_SIZE, &tmp) != Success || tmp != 0)
x11: Rework Visual selection Instead of going via GdkVisual, doing a preselection and letting the GL initialization improve it, let the GL initialization pick an X Visual directly using X Visual code directly. The code should select the same visuals as before as it tries to apply the same logic, but it's a rewrite, so I expect I messed something up.
2021-06-13 15:34:55 +00:00
{
if (best_features < WITH_STENCIL_AND_DEPTH_BUFFER)
{
x11: Use single GLX fbconfig and store it in the display This mirrors the code for the EGL config.
2021-06-29 20:10:48 +00:00
GDK_NOTE (OPENGL, g_message ("Best GLX config is %u for visual 0x%lX with a stencil or depth buffer", i, visinfo->visualid));
x11: Rework Visual selection Instead of going via GdkVisual, doing a preselection and letting the GL initialization improve it, let the GL initialization pick an X Visual directly using X Visual code directly. The code should select the same visuals as before as it tries to apply the same logic, but it's a rewrite, so I expect I messed something up.
2021-06-13 15:34:55 +00:00
best_features = WITH_STENCIL_AND_DEPTH_BUFFER;
x11: Use single GLX fbconfig and store it in the display This mirrors the code for the EGL config.
2021-06-29 20:10:48 +00:00
*out_visual = visinfo->visual;
*out_depth = visinfo->depth;
self->glx_config = configs[i];
x11: Rework Visual selection Instead of going via GdkVisual, doing a preselection and letting the GL initialization improve it, let the GL initialization pick an X Visual directly using X Visual code directly. The code should select the same visuals as before as it tries to apply the same logic, but it's a rewrite, so I expect I messed something up.
2021-06-13 15:34:55 +00:00
}
x11: Use single GLX fbconfig and store it in the display This mirrors the code for the EGL config.
2021-06-29 20:10:48 +00:00
XFree (visinfo);
x11: Rework Visual selection Instead of going via GdkVisual, doing a preselection and letting the GL initialization improve it, let the GL initialization pick an X Visual directly using X Visual code directly. The code should select the same visuals as before as it tries to apply the same logic, but it's a rewrite, so I expect I messed something up.
2021-06-13 15:34:55 +00:00
continue;
}
x11: Use single GLX fbconfig and store it in the display This mirrors the code for the EGL config.
2021-06-29 20:10:48 +00:00
if (!visual_is_rgba (visinfo))
x11: Rework Visual selection Instead of going via GdkVisual, doing a preselection and letting the GL initialization improve it, let the GL initialization pick an X Visual directly using X Visual code directly. The code should select the same visuals as before as it tries to apply the same logic, but it's a rewrite, so I expect I messed something up.
2021-06-13 15:34:55 +00:00
{
if (best_features < NO_ALPHA_VISUAL)
{
x11: Use single GLX fbconfig and store it in the display This mirrors the code for the EGL config.
2021-06-29 20:10:48 +00:00
GDK_NOTE (OPENGL, g_message ("Best GLX config is %u for visual 0x%lX with no RGBA Visual", i, visinfo->visualid));
x11: Rework Visual selection Instead of going via GdkVisual, doing a preselection and letting the GL initialization improve it, let the GL initialization pick an X Visual directly using X Visual code directly. The code should select the same visuals as before as it tries to apply the same logic, but it's a rewrite, so I expect I messed something up.
2021-06-13 15:34:55 +00:00
best_features = NO_ALPHA_VISUAL;
x11: Use single GLX fbconfig and store it in the display This mirrors the code for the EGL config.
2021-06-29 20:10:48 +00:00
*out_visual = visinfo->visual;
*out_depth = visinfo->depth;
self->glx_config = configs[i];
x11: Rework Visual selection Instead of going via GdkVisual, doing a preselection and letting the GL initialization improve it, let the GL initialization pick an X Visual directly using X Visual code directly. The code should select the same visuals as before as it tries to apply the same logic, but it's a rewrite, so I expect I messed something up.
2021-06-13 15:34:55 +00:00
}
x11: Use single GLX fbconfig and store it in the display This mirrors the code for the EGL config.
2021-06-29 20:10:48 +00:00
XFree (visinfo);
x11: Rework Visual selection Instead of going via GdkVisual, doing a preselection and letting the GL initialization improve it, let the GL initialization pick an X Visual directly using X Visual code directly. The code should select the same visuals as before as it tries to apply the same logic, but it's a rewrite, so I expect I messed something up.
2021-06-13 15:34:55 +00:00
continue;
}
x11: Decouple GLX from GdkX11GLContext If we want to add an EGL implementation for the X11 backend, we are going to need to move the GLX bits into their own class. The first step is to declare GdkX11GLContext as an abstract type, and then subclass it into a GdkX11GLContextGLX type, which includes the whole GLX implementation.
2021-05-10 14:07:08 +00:00
x11: Use single GLX fbconfig and store it in the display This mirrors the code for the EGL config.
2021-06-29 20:10:48 +00:00
GDK_NOTE (OPENGL, g_message ("GLX config %u for visual 0x%lX is the perfect choice", i, visinfo->visualid));
best_features = PERFECT;
*out_visual = visinfo->visual;
*out_depth = visinfo->depth;
self->glx_config = configs[i];
XFree (visinfo);
x11: Rework Visual selection Instead of going via GdkVisual, doing a preselection and letting the GL initialization improve it, let the GL initialization pick an X Visual directly using X Visual code directly. The code should select the same visuals as before as it tries to apply the same logic, but it's a rewrite, so I expect I messed something up.
2021-06-13 15:34:55 +00:00
break;
}
x11: Use single GLX fbconfig and store it in the display This mirrors the code for the EGL config.
2021-06-29 20:10:48 +00:00
XFree (configs);
x11: Properly record the error when initializing GL That way, we can give a useful error message when things break down for users. These error messages could still be improved in places (like looking at the actual EGL error codes), but that seemed overkill.
2021-07-02 01:21:14 +00:00
if (best_features == NO_VISUAL_FOUND)
{
g_set_error_literal (error, GDK_GL_ERROR,
GDK_GL_ERROR_NOT_AVAILABLE,
_("No GLX configuration with required features found"));
return FALSE;
}
return TRUE;
x11: Decouple GLX from GdkX11GLContext If we want to add an EGL implementation for the X11 backend, we are going to need to move the GLX bits into their own class. The first step is to declare GdkX11GLContext as an abstract type, and then subclass it into a GdkX11GLContextGLX type, which includes the whole GLX implementation.
2021-05-10 14:07:08 +00:00
}
x11: Use single GLX fbconfig and store it in the display This mirrors the code for the EGL config.
2021-06-29 20:10:48 +00:00
#undef MAX_GLX_ATTRS
x11: Decouple GLX from GdkX11GLContext If we want to add an EGL implementation for the X11 backend, we are going to need to move the GLX bits into their own class. The first step is to declare GdkX11GLContext as an abstract type, and then subclass it into a GdkX11GLContextGLX type, which includes the whole GLX implementation.
2021-05-10 14:07:08 +00:00
/**
* gdk_x11_display_get_glx_version:
gdk: Clean up docs syntax Replace leftover gtk-doc syntax (#Type) with backquotes.
2021-05-20 03:39:18 +00:00
* @display: (type GdkX11Display): a `GdkDisplay`
x11: Decouple GLX from GdkX11GLContext If we want to add an EGL implementation for the X11 backend, we are going to need to move the GLX bits into their own class. The first step is to declare GdkX11GLContext as an abstract type, and then subclass it into a GdkX11GLContextGLX type, which includes the whole GLX implementation.
2021-05-10 14:07:08 +00:00
* @major: (out): return location for the GLX major version
* @minor: (out): return location for the GLX minor version
*
* Retrieves the version of the GLX implementation.
*
* Returns: %TRUE if GLX is available
*/
gboolean
gdk_x11_display_get_glx_version (GdkDisplay *display,
int *major,
int *minor)
{
g_return_val_if_fail (GDK_IS_DISPLAY (display), FALSE);
if (!GDK_IS_X11_DISPLAY (display))
return FALSE;
GdkX11Display *display_x11 = GDK_X11_DISPLAY (display);
x11: Use single GLX fbconfig and store it in the display This mirrors the code for the EGL config.
2021-06-29 20:10:48 +00:00
if (display_x11->glx_config == NULL)
x11: Decouple GLX from GdkX11GLContext If we want to add an EGL implementation for the X11 backend, we are going to need to move the GLX bits into their own class. The first step is to declare GdkX11GLContext as an abstract type, and then subclass it into a GdkX11GLContextGLX type, which includes the whole GLX implementation.
2021-05-10 14:07:08 +00:00
return FALSE;
if (major != NULL)
*major = display_x11->glx_version / 10;
if (minor != NULL)
*minor = display_x11->glx_version % 10;
return TRUE;
}
/*< private >
x11: Pass the display, not the screen Screens are on their way out.
2021-06-06 17:56:35 +00:00
* gdk_x11_display_init_glx:
* @display_x11: an X11 display that has not been inited yet.
x11: Rework Visual selection Instead of going via GdkVisual, doing a preselection and letting the GL initialization improve it, let the GL initialization pick an X Visual directly using X Visual code directly. The code should select the same visuals as before as it tries to apply the same logic, but it's a rewrite, so I expect I messed something up.
2021-06-13 15:34:55 +00:00
* @out_visual: set to the Visual to be used with the returned config
* @out_depth: set to the depth to be used with the returned config
x11: Properly record the error when initializing GL That way, we can give a useful error message when things break down for users. These error messages could still be improved in places (like looking at the actual EGL error codes), but that seemed overkill.
2021-07-02 01:21:14 +00:00
* @error: Return location for error
x11: Decouple GLX from GdkX11GLContext If we want to add an EGL implementation for the X11 backend, we are going to need to move the GLX bits into their own class. The first step is to declare GdkX11GLContext as an abstract type, and then subclass it into a GdkX11GLContextGLX type, which includes the whole GLX implementation.
2021-05-10 14:07:08 +00:00
*
* Initializes the cached GLX state for the given @screen.
*
x11: Pass the display, not the screen Screens are on their way out.
2021-06-06 17:56:35 +00:00
* This function must be called exactly once during initialization.
x11: Decouple GLX from GdkX11GLContext If we want to add an EGL implementation for the X11 backend, we are going to need to move the GLX bits into their own class. The first step is to declare GdkX11GLContext as an abstract type, and then subclass it into a GdkX11GLContextGLX type, which includes the whole GLX implementation.
2021-05-10 14:07:08 +00:00
*
* Returns: %TRUE if GLX was initialized
*/
gboolean
x11: Rework Visual selection Instead of going via GdkVisual, doing a preselection and letting the GL initialization improve it, let the GL initialization pick an X Visual directly using X Visual code directly. The code should select the same visuals as before as it tries to apply the same logic, but it's a rewrite, so I expect I messed something up.
2021-06-13 15:34:55 +00:00
gdk_x11_display_init_glx (GdkX11Display *display_x11,
Visual **out_visual,
x11: Properly record the error when initializing GL That way, we can give a useful error message when things break down for users. These error messages could still be improved in places (like looking at the actual EGL error codes), but that seemed overkill.
2021-07-02 01:21:14 +00:00
int *out_depth,
GError **error)
x11: Decouple GLX from GdkX11GLContext If we want to add an EGL implementation for the X11 backend, we are going to need to move the GLX bits into their own class. The first step is to declare GdkX11GLContext as an abstract type, and then subclass it into a GdkX11GLContextGLX type, which includes the whole GLX implementation.
2021-05-10 14:07:08 +00:00
{
x11: Pass the display, not the screen Screens are on their way out.
2021-06-06 17:56:35 +00:00
GdkDisplay *display = GDK_DISPLAY (display_x11);
x11: Decouple GLX from GdkX11GLContext If we want to add an EGL implementation for the X11 backend, we are going to need to move the GLX bits into their own class. The first step is to declare GdkX11GLContext as an abstract type, and then subclass it into a GdkX11GLContextGLX type, which includes the whole GLX implementation.
2021-05-10 14:07:08 +00:00
Display *dpy;
int screen_num;
gdk: Make sure only one GL backend is used Creative people managed to create an X11 display and a Wayland display at once, thereby getting EGL and GLX involved in a fight to the death over the ownership of the glFoo() symbolspace. A way to force such a fight with available tools here is (on Wayland) running something like: GTK_INSPECTOR_DISPLAY=:1 GTK_DEBUG=interactive gtk4-demo Related: xdg-desktop-portal-gnome#5
2021-09-23 23:47:03 +00:00
if (!gdk_gl_backend_can_be_used (GDK_GL_GLX, error))
return FALSE;
x11: Decouple GLX from GdkX11GLContext If we want to add an EGL implementation for the X11 backend, we are going to need to move the GLX bits into their own class. The first step is to declare GdkX11GLContext as an abstract type, and then subclass it into a GdkX11GLContextGLX type, which includes the whole GLX implementation.
2021-05-10 14:07:08 +00:00
dpy = gdk_x11_display_get_xdisplay (display);
if (!epoxy_has_glx (dpy))
x11: Properly record the error when initializing GL That way, we can give a useful error message when things break down for users. These error messages could still be improved in places (like looking at the actual EGL error codes), but that seemed overkill.
2021-07-02 01:21:14 +00:00
{
g_set_error_literal (error, GDK_GL_ERROR,
GDK_GL_ERROR_NOT_AVAILABLE,
_("GLX is not supported"));
return FALSE;
}
x11: Decouple GLX from GdkX11GLContext If we want to add an EGL implementation for the X11 backend, we are going to need to move the GLX bits into their own class. The first step is to declare GdkX11GLContext as an abstract type, and then subclass it into a GdkX11GLContextGLX type, which includes the whole GLX implementation.
2021-05-10 14:07:08 +00:00
x11: Pass the display, not the screen Screens are on their way out.
2021-06-06 17:56:35 +00:00
screen_num = display_x11->screen->screen_num;
x11: Decouple GLX from GdkX11GLContext If we want to add an EGL implementation for the X11 backend, we are going to need to move the GLX bits into their own class. The first step is to declare GdkX11GLContext as an abstract type, and then subclass it into a GdkX11GLContextGLX type, which includes the whole GLX implementation.
2021-05-10 14:07:08 +00:00
display_x11->glx_version = epoxy_glx_version (dpy, screen_num);
display_x11->has_glx_create_context =
epoxy_has_glx_extension (dpy, screen_num, "GLX_ARB_create_context_profile");
display_x11->has_glx_create_es2_context =
epoxy_has_glx_extension (dpy, screen_num, "GLX_EXT_create_context_es2_profile");
display_x11->has_glx_swap_interval =
epoxy_has_glx_extension (dpy, screen_num, "GLX_SGI_swap_control");
display_x11->has_glx_texture_from_pixmap =
epoxy_has_glx_extension (dpy, screen_num, "GLX_EXT_texture_from_pixmap");
display_x11->has_glx_video_sync =
epoxy_has_glx_extension (dpy, screen_num, "GLX_SGI_video_sync");
display_x11->has_glx_buffer_age =
epoxy_has_glx_extension (dpy, screen_num, "GLX_EXT_buffer_age");
display_x11->has_glx_sync_control =
epoxy_has_glx_extension (dpy, screen_num, "GLX_OML_sync_control");
display_x11->has_glx_multisample =
epoxy_has_glx_extension (dpy, screen_num, "GLX_ARB_multisample");
display_x11->has_glx_visual_rating =
epoxy_has_glx_extension (dpy, screen_num, "GLX_EXT_visual_rating");
if (g_strcmp0 (glXGetClientString (dpy, GLX_VENDOR), "NVIDIA Corporation") == 0)
{
x11: Be more careful with NVIDIA workaround Check that we are indeed running inside an Xorg server before enabling the workaround. XWayland or other nested X servers deadlock when that workaround is applied.
2021-05-21 23:43:31 +00:00
Atom type;
int format;
gulong nitems;
gulong bytes_after;
guchar *data = NULL;
x11: Decouple GLX from GdkX11GLContext If we want to add an EGL implementation for the X11 backend, we are going to need to move the GLX bits into their own class. The first step is to declare GdkX11GLContext as an abstract type, and then subclass it into a GdkX11GLContextGLX type, which includes the whole GLX implementation.
2021-05-10 14:07:08 +00:00
/* With the mesa based drivers, we can safely assume the compositor can
* access the updated surface texture immediately after glXSwapBuffers is
* run, because the kernel ensures there is an implicit synchronization
* operation upon texture access. This is not true with the Nvidia vendor
* driver. There is a window of time after glXSwapBuffers before other
* processes can see the updated drawing. We need to take special care,
* in that case, to defer telling the compositor our latest frame is
* ready until after the GPU has completed all issued commands related
* to the frame, and that the X server says the frame has been drawn.
x11: Be more careful with NVIDIA workaround Check that we are indeed running inside an Xorg server before enabling the workaround. XWayland or other nested X servers deadlock when that workaround is applied.
2021-05-21 23:43:31 +00:00
*
* As this can cause deadlocks, we want to make sure to only enable it for Xorg,
* but not for XWayland, Xnest or whatever other X servers exist.
x11: Decouple GLX from GdkX11GLContext If we want to add an EGL implementation for the X11 backend, we are going to need to move the GLX bits into their own class. The first step is to declare GdkX11GLContext as an abstract type, and then subclass it into a GdkX11GLContextGLX type, which includes the whole GLX implementation.
2021-05-10 14:07:08 +00:00
*/
x11: Be more careful with NVIDIA workaround Check that we are indeed running inside an Xorg server before enabling the workaround. XWayland or other nested X servers deadlock when that workaround is applied.
2021-05-21 23:43:31 +00:00
gdk_x11_display_error_trap_push (display);
if (XGetWindowProperty (dpy, DefaultRootWindow (dpy),
gdk_x11_get_xatom_by_name_for_display (display, "XFree86_VT"),
0, 1, False, AnyPropertyType,
&type, &format, &nitems, &bytes_after, &data) == Success)
{
if (type != None)
display_x11->has_async_glx_swap_buffers = TRUE;
}
gdk_x11_display_error_trap_pop_ignored (display);
if (data)
XFree (data);
x11: Decouple GLX from GdkX11GLContext If we want to add an EGL implementation for the X11 backend, we are going to need to move the GLX bits into their own class. The first step is to declare GdkX11GLContext as an abstract type, and then subclass it into a GdkX11GLContextGLX type, which includes the whole GLX implementation.
2021-05-10 14:07:08 +00:00
}
x11: Properly record the error when initializing GL That way, we can give a useful error message when things break down for users. These error messages could still be improved in places (like looking at the actual EGL error codes), but that seemed overkill.
2021-07-02 01:21:14 +00:00
if (!gdk_x11_display_create_glx_config (display_x11, out_visual, out_depth, error))
x11: Use single GLX fbconfig and store it in the display This mirrors the code for the EGL config.
2021-06-29 20:10:48 +00:00
return FALSE;
x11: Decouple GLX from GdkX11GLContext If we want to add an EGL implementation for the X11 backend, we are going to need to move the GLX bits into their own class. The first step is to declare GdkX11GLContext as an abstract type, and then subclass it into a GdkX11GLContextGLX type, which includes the whole GLX implementation.
2021-05-10 14:07:08 +00:00
GDK_DISPLAY_NOTE (display, OPENGL,
g_message ("GLX version %d.%d found\n"
" - Vendor: %s\n"
" - Checked extensions:\n"
"\t* GLX_ARB_create_context_profile: %s\n"
"\t* GLX_EXT_create_context_es2_profile: %s\n"
"\t* GLX_SGI_swap_control: %s\n"
"\t* GLX_EXT_texture_from_pixmap: %s\n"
"\t* GLX_SGI_video_sync: %s\n"
"\t* GLX_EXT_buffer_age: %s\n"
"\t* GLX_OML_sync_control: %s"
"\t* GLX_ARB_multisample: %s"
"\t* GLX_EXT_visual_rating: %s",
display_x11->glx_version / 10,
display_x11->glx_version % 10,
glXGetClientString (dpy, GLX_VENDOR),
display_x11->has_glx_create_context ? "yes" : "no",
display_x11->has_glx_create_es2_context ? "yes" : "no",
display_x11->has_glx_swap_interval ? "yes" : "no",
display_x11->has_glx_texture_from_pixmap ? "yes" : "no",
display_x11->has_glx_video_sync ? "yes" : "no",
display_x11->has_glx_buffer_age ? "yes" : "no",
display_x11->has_glx_sync_control ? "yes" : "no",
display_x11->has_glx_multisample ? "yes" : "no",
display_x11->has_glx_visual_rating ? "yes" : "no"));
x11: Use single GLX fbconfig and store it in the display This mirrors the code for the EGL config.
2021-06-29 20:10:48 +00:00
return TRUE;
x11: Decouple GLX from GdkX11GLContext If we want to add an EGL implementation for the X11 backend, we are going to need to move the GLX bits into their own class. The first step is to declare GdkX11GLContext as an abstract type, and then subclass it into a GdkX11GLContextGLX type, which includes the whole GLX implementation.
2021-05-10 14:07:08 +00:00
}
Reference in New Issue Copy Permalink