AuroraMiddleware/gtk
1
0
Fork 1
mirror of https://gitlab.gnome.org/GNOME/gtk.git synced 2024-11-08 17:50:10 +00:00
Code Issues Projects Releases Wiki Activity
60ddf7c421
gtk/gdk/gdkglcontext.c

2358 lines
75 KiB
C
Raw Normal View History

gdk: Add support for OpenGL This adds the new type GdkGLContext that wraps an OpenGL context for a particular native window. It also adds support for the gdk paint machinery to use OpenGL to draw everything. As soon as anyone creates a GL context for a native window we create a "paint context" for that GdkWindow and switch to using GL for painting it. This commit contains only an implementation for X11 (using GLX). The way painting works is that all client gl contexts draw into offscreen buffers rather than directly to the back buffer, and the way something gets onto the window is by using gdk_cairo_draw_from_gl() to draw part of that buffer onto the draw cairo context. As a fallback (if we're doing redirected drawing or some effect like a cairo_push_group()) we read back the gl buffer into memory and composite using cairo. This means that GL rendering works in all cases, including rendering to a PDF. However, this is not particularly fast. In the *typical* case, where we're drawing directly to the window in the regular paint loop we hit the fast path. The fast path uses opengl to draw the buffer to the window back buffer, either by blitting or texturing. Then we track the region that was drawn, and when the draw ends we paint the normal cairo surface to the window (using texture-from-pixmap in the X11 case, or texture from cairo image otherwise) in the regions where there is no gl painted. There are some complexities wrt layering of gl and cairo areas though: * We track via gdk_window_mark_paint_from_clip() whenever gtk is painting over a region we previously rendered with opengl (flushed_region). This area (needs_blend_region) is blended rather than copied at the end of the frame. * If we're drawing a gl texture with alpha we first copy the current cairo_surface inside the target region to the back buffer before we blend over it. These two operations allow us full stacking of transparent gl and cairo regions.
2014-10-09 08:45:44 +00:00
/* GDK - The GIMP Drawing Kit
*
* gdkglcontext.c: GL context abstraction
gdk: Check OES_vertex_half_float GLES extension This will be checked in the GL renderer.
2022-05-05 17:08:32 +00:00
*
gdk: Add support for OpenGL This adds the new type GdkGLContext that wraps an OpenGL context for a particular native window. It also adds support for the gdk paint machinery to use OpenGL to draw everything. As soon as anyone creates a GL context for a native window we create a "paint context" for that GdkWindow and switch to using GL for painting it. This commit contains only an implementation for X11 (using GLX). The way painting works is that all client gl contexts draw into offscreen buffers rather than directly to the back buffer, and the way something gets onto the window is by using gdk_cairo_draw_from_gl() to draw part of that buffer onto the draw cairo context. As a fallback (if we're doing redirected drawing or some effect like a cairo_push_group()) we read back the gl buffer into memory and composite using cairo. This means that GL rendering works in all cases, including rendering to a PDF. However, this is not particularly fast. In the *typical* case, where we're drawing directly to the window in the regular paint loop we hit the fast path. The fast path uses opengl to draw the buffer to the window back buffer, either by blitting or texturing. Then we track the region that was drawn, and when the draw ends we paint the normal cairo surface to the window (using texture-from-pixmap in the X11 case, or texture from cairo image otherwise) in the regions where there is no gl painted. There are some complexities wrt layering of gl and cairo areas though: * We track via gdk_window_mark_paint_from_clip() whenever gtk is painting over a region we previously rendered with opengl (flushed_region). This area (needs_blend_region) is blended rather than copied at the end of the frame. * If we're drawing a gl texture with alpha we first copy the current cairo_surface inside the target region to the back buffer before we blend over it. These two operations allow us full stacking of transparent gl and cairo regions.
2014-10-09 08:45:44 +00:00
* Copyright © 2014 Emmanuele Bassi
*
* 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/>.
*/
/**
docs: Rework the gdk docs Convert links, make things more concise.
2021-02-21 05:13:57 +00:00
* GdkGLContext:
gdk: Add support for OpenGL This adds the new type GdkGLContext that wraps an OpenGL context for a particular native window. It also adds support for the gdk paint machinery to use OpenGL to draw everything. As soon as anyone creates a GL context for a native window we create a "paint context" for that GdkWindow and switch to using GL for painting it. This commit contains only an implementation for X11 (using GLX). The way painting works is that all client gl contexts draw into offscreen buffers rather than directly to the back buffer, and the way something gets onto the window is by using gdk_cairo_draw_from_gl() to draw part of that buffer onto the draw cairo context. As a fallback (if we're doing redirected drawing or some effect like a cairo_push_group()) we read back the gl buffer into memory and composite using cairo. This means that GL rendering works in all cases, including rendering to a PDF. However, this is not particularly fast. In the *typical* case, where we're drawing directly to the window in the regular paint loop we hit the fast path. The fast path uses opengl to draw the buffer to the window back buffer, either by blitting or texturing. Then we track the region that was drawn, and when the draw ends we paint the normal cairo surface to the window (using texture-from-pixmap in the X11 case, or texture from cairo image otherwise) in the regions where there is no gl painted. There are some complexities wrt layering of gl and cairo areas though: * We track via gdk_window_mark_paint_from_clip() whenever gtk is painting over a region we previously rendered with opengl (flushed_region). This area (needs_blend_region) is blended rather than copied at the end of the frame. * If we're drawing a gl texture with alpha we first copy the current cairo_surface inside the target region to the back buffer before we blend over it. These two operations allow us full stacking of transparent gl and cairo regions.
2014-10-09 08:45:44 +00:00
*
docs: Rework the gdk docs Convert links, make things more concise.
2021-02-21 05:13:57 +00:00
* `GdkGLContext` is an object representing a platform-specific
gdk: Cosmetic rewording of draw context docs Avoid draw context <> drawing context confusion, as far as possible.
2017-12-26 19:10:54 +00:00
* OpenGL draw context.
gdk: Add support for OpenGL This adds the new type GdkGLContext that wraps an OpenGL context for a particular native window. It also adds support for the gdk paint machinery to use OpenGL to draw everything. As soon as anyone creates a GL context for a native window we create a "paint context" for that GdkWindow and switch to using GL for painting it. This commit contains only an implementation for X11 (using GLX). The way painting works is that all client gl contexts draw into offscreen buffers rather than directly to the back buffer, and the way something gets onto the window is by using gdk_cairo_draw_from_gl() to draw part of that buffer onto the draw cairo context. As a fallback (if we're doing redirected drawing or some effect like a cairo_push_group()) we read back the gl buffer into memory and composite using cairo. This means that GL rendering works in all cases, including rendering to a PDF. However, this is not particularly fast. In the *typical* case, where we're drawing directly to the window in the regular paint loop we hit the fast path. The fast path uses opengl to draw the buffer to the window back buffer, either by blitting or texturing. Then we track the region that was drawn, and when the draw ends we paint the normal cairo surface to the window (using texture-from-pixmap in the X11 case, or texture from cairo image otherwise) in the regions where there is no gl painted. There are some complexities wrt layering of gl and cairo areas though: * We track via gdk_window_mark_paint_from_clip() whenever gtk is painting over a region we previously rendered with opengl (flushed_region). This area (needs_blend_region) is blended rather than copied at the end of the frame. * If we're drawing a gl texture with alpha we first copy the current cairo_surface inside the target region to the back buffer before we blend over it. These two operations allow us full stacking of transparent gl and cairo regions.
2014-10-09 08:45:44 +00:00
*
docs: Rework the gdk docs Convert links, make things more concise.
2021-02-21 05:13:57 +00:00
* `GdkGLContext`s are created for a surface using
* [method@Gdk.Surface.create_gl_context], and the context will match
docs: Cosmetics Do a round of "the the" removal.
2021-10-17 20:05:35 +00:00
* the characteristics of the 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
*
docs: Rework the gdk docs Convert links, make things more concise.
2021-02-21 05:13:57 +00:00
* A `GdkGLContext` is not tied to any particular normal framebuffer.
* For instance, it cannot draw to the surface back buffer. The GDK
Nitpicky documentation changes
2014-10-12 03:35:52 +00:00
* repaint system is in full control of the painting to that. Instead,
docs: Rework the gdk docs Convert links, make things more concise.
2021-02-21 05:13:57 +00:00
* you can create render buffers or textures and use [func@cairo_draw_from_gl]
Nitpicky documentation changes
2014-10-12 03:35:52 +00:00
* in the draw function of your widget to draw them. Then GDK will handle
* the integration of your rendering with that of other widgets.
gdk: Add support for OpenGL This adds the new type GdkGLContext that wraps an OpenGL context for a particular native window. It also adds support for the gdk paint machinery to use OpenGL to draw everything. As soon as anyone creates a GL context for a native window we create a "paint context" for that GdkWindow and switch to using GL for painting it. This commit contains only an implementation for X11 (using GLX). The way painting works is that all client gl contexts draw into offscreen buffers rather than directly to the back buffer, and the way something gets onto the window is by using gdk_cairo_draw_from_gl() to draw part of that buffer onto the draw cairo context. As a fallback (if we're doing redirected drawing or some effect like a cairo_push_group()) we read back the gl buffer into memory and composite using cairo. This means that GL rendering works in all cases, including rendering to a PDF. However, this is not particularly fast. In the *typical* case, where we're drawing directly to the window in the regular paint loop we hit the fast path. The fast path uses opengl to draw the buffer to the window back buffer, either by blitting or texturing. Then we track the region that was drawn, and when the draw ends we paint the normal cairo surface to the window (using texture-from-pixmap in the X11 case, or texture from cairo image otherwise) in the regions where there is no gl painted. There are some complexities wrt layering of gl and cairo areas though: * We track via gdk_window_mark_paint_from_clip() whenever gtk is painting over a region we previously rendered with opengl (flushed_region). This area (needs_blend_region) is blended rather than copied at the end of the frame. * If we're drawing a gl texture with alpha we first copy the current cairo_surface inside the target region to the back buffer before we blend over it. These two operations allow us full stacking of transparent gl and cairo regions.
2014-10-09 08:45:44 +00:00
*
docs: Rework the gdk docs Convert links, make things more concise.
2021-02-21 05:13:57 +00:00
* Support for `GdkGLContext` is platform-specific and context creation
Trivial formatting fixes
2014-10-12 03:17:34 +00:00
* can fail, returning %NULL context.
gdk: Add support for OpenGL This adds the new type GdkGLContext that wraps an OpenGL context for a particular native window. It also adds support for the gdk paint machinery to use OpenGL to draw everything. As soon as anyone creates a GL context for a native window we create a "paint context" for that GdkWindow and switch to using GL for painting it. This commit contains only an implementation for X11 (using GLX). The way painting works is that all client gl contexts draw into offscreen buffers rather than directly to the back buffer, and the way something gets onto the window is by using gdk_cairo_draw_from_gl() to draw part of that buffer onto the draw cairo context. As a fallback (if we're doing redirected drawing or some effect like a cairo_push_group()) we read back the gl buffer into memory and composite using cairo. This means that GL rendering works in all cases, including rendering to a PDF. However, this is not particularly fast. In the *typical* case, where we're drawing directly to the window in the regular paint loop we hit the fast path. The fast path uses opengl to draw the buffer to the window back buffer, either by blitting or texturing. Then we track the region that was drawn, and when the draw ends we paint the normal cairo surface to the window (using texture-from-pixmap in the X11 case, or texture from cairo image otherwise) in the regions where there is no gl painted. There are some complexities wrt layering of gl and cairo areas though: * We track via gdk_window_mark_paint_from_clip() whenever gtk is painting over a region we previously rendered with opengl (flushed_region). This area (needs_blend_region) is blended rather than copied at the end of the frame. * If we're drawing a gl texture with alpha we first copy the current cairo_surface inside the target region to the back buffer before we blend over it. These two operations allow us full stacking of transparent gl and cairo regions.
2014-10-09 08:45:44 +00:00
*
docs: Rework the gdk docs Convert links, make things more concise.
2021-02-21 05:13:57 +00:00
* A `GdkGLContext` has to be made "current" in order to start using
gdk: Add support for OpenGL This adds the new type GdkGLContext that wraps an OpenGL context for a particular native window. It also adds support for the gdk paint machinery to use OpenGL to draw everything. As soon as anyone creates a GL context for a native window we create a "paint context" for that GdkWindow and switch to using GL for painting it. This commit contains only an implementation for X11 (using GLX). The way painting works is that all client gl contexts draw into offscreen buffers rather than directly to the back buffer, and the way something gets onto the window is by using gdk_cairo_draw_from_gl() to draw part of that buffer onto the draw cairo context. As a fallback (if we're doing redirected drawing or some effect like a cairo_push_group()) we read back the gl buffer into memory and composite using cairo. This means that GL rendering works in all cases, including rendering to a PDF. However, this is not particularly fast. In the *typical* case, where we're drawing directly to the window in the regular paint loop we hit the fast path. The fast path uses opengl to draw the buffer to the window back buffer, either by blitting or texturing. Then we track the region that was drawn, and when the draw ends we paint the normal cairo surface to the window (using texture-from-pixmap in the X11 case, or texture from cairo image otherwise) in the regions where there is no gl painted. There are some complexities wrt layering of gl and cairo areas though: * We track via gdk_window_mark_paint_from_clip() whenever gtk is painting over a region we previously rendered with opengl (flushed_region). This area (needs_blend_region) is blended rather than copied at the end of the frame. * If we're drawing a gl texture with alpha we first copy the current cairo_surface inside the target region to the back buffer before we blend over it. These two operations allow us full stacking of transparent gl and cairo regions.
2014-10-09 08:45:44 +00:00
* it, otherwise any OpenGL call will be ignored.
*
docs: Rework the gdk docs Convert links, make things more concise.
2021-02-21 05:13:57 +00:00
* ## Creating a new OpenGL context
gdk: Add support for OpenGL This adds the new type GdkGLContext that wraps an OpenGL context for a particular native window. It also adds support for the gdk paint machinery to use OpenGL to draw everything. As soon as anyone creates a GL context for a native window we create a "paint context" for that GdkWindow and switch to using GL for painting it. This commit contains only an implementation for X11 (using GLX). The way painting works is that all client gl contexts draw into offscreen buffers rather than directly to the back buffer, and the way something gets onto the window is by using gdk_cairo_draw_from_gl() to draw part of that buffer onto the draw cairo context. As a fallback (if we're doing redirected drawing or some effect like a cairo_push_group()) we read back the gl buffer into memory and composite using cairo. This means that GL rendering works in all cases, including rendering to a PDF. However, this is not particularly fast. In the *typical* case, where we're drawing directly to the window in the regular paint loop we hit the fast path. The fast path uses opengl to draw the buffer to the window back buffer, either by blitting or texturing. Then we track the region that was drawn, and when the draw ends we paint the normal cairo surface to the window (using texture-from-pixmap in the X11 case, or texture from cairo image otherwise) in the regions where there is no gl painted. There are some complexities wrt layering of gl and cairo areas though: * We track via gdk_window_mark_paint_from_clip() whenever gtk is painting over a region we previously rendered with opengl (flushed_region). This area (needs_blend_region) is blended rather than copied at the end of the frame. * If we're drawing a gl texture with alpha we first copy the current cairo_surface inside the target region to the back buffer before we blend over it. These two operations allow us full stacking of transparent gl and cairo regions.
2014-10-09 08:45:44 +00:00
*
docs: Rework the gdk docs Convert links, make things more concise.
2021-02-21 05:13:57 +00:00
* In order to create a new `GdkGLContext` instance you need a `GdkSurface`,
* which you typically get during the realize call of a widget.
gdk: Add support for OpenGL This adds the new type GdkGLContext that wraps an OpenGL context for a particular native window. It also adds support for the gdk paint machinery to use OpenGL to draw everything. As soon as anyone creates a GL context for a native window we create a "paint context" for that GdkWindow and switch to using GL for painting it. This commit contains only an implementation for X11 (using GLX). The way painting works is that all client gl contexts draw into offscreen buffers rather than directly to the back buffer, and the way something gets onto the window is by using gdk_cairo_draw_from_gl() to draw part of that buffer onto the draw cairo context. As a fallback (if we're doing redirected drawing or some effect like a cairo_push_group()) we read back the gl buffer into memory and composite using cairo. This means that GL rendering works in all cases, including rendering to a PDF. However, this is not particularly fast. In the *typical* case, where we're drawing directly to the window in the regular paint loop we hit the fast path. The fast path uses opengl to draw the buffer to the window back buffer, either by blitting or texturing. Then we track the region that was drawn, and when the draw ends we paint the normal cairo surface to the window (using texture-from-pixmap in the X11 case, or texture from cairo image otherwise) in the regions where there is no gl painted. There are some complexities wrt layering of gl and cairo areas though: * We track via gdk_window_mark_paint_from_clip() whenever gtk is painting over a region we previously rendered with opengl (flushed_region). This area (needs_blend_region) is blended rather than copied at the end of the frame. * If we're drawing a gl texture with alpha we first copy the current cairo_surface inside the target region to the back buffer before we blend over it. These two operations allow us full stacking of transparent gl and cairo regions.
2014-10-09 08:45:44 +00:00
*
docs: Rework the gdk docs Convert links, make things more concise.
2021-02-21 05:13:57 +00:00
* A `GdkGLContext` is not realized until either [method@Gdk.GLContext.make_current]
* or [method@Gdk.GLContext.realize] is called. It is possible to specify
* details of the GL context like the OpenGL version to be used, or whether
* the GL context should have extra state validation enabled after calling
* [method@Gdk.Surface.create_gl_context] by calling [method@Gdk.GLContext.realize].
* If the realization fails you have the option to change the settings of
* the `GdkGLContext` and try again.
docs: We do not support non-core GL profiles No need to mention that some API only works on core GL profiles in the GdkGLContext docs. https://bugzilla.gnome.org/show_bug.cgi?id=741946
2015-02-09 16:09:25 +00:00
*
docs: Rework the gdk docs Convert links, make things more concise.
2021-02-21 05:13:57 +00:00
* ## Using a GdkGLContext
gdk: Add support for OpenGL This adds the new type GdkGLContext that wraps an OpenGL context for a particular native window. It also adds support for the gdk paint machinery to use OpenGL to draw everything. As soon as anyone creates a GL context for a native window we create a "paint context" for that GdkWindow and switch to using GL for painting it. This commit contains only an implementation for X11 (using GLX). The way painting works is that all client gl contexts draw into offscreen buffers rather than directly to the back buffer, and the way something gets onto the window is by using gdk_cairo_draw_from_gl() to draw part of that buffer onto the draw cairo context. As a fallback (if we're doing redirected drawing or some effect like a cairo_push_group()) we read back the gl buffer into memory and composite using cairo. This means that GL rendering works in all cases, including rendering to a PDF. However, this is not particularly fast. In the *typical* case, where we're drawing directly to the window in the regular paint loop we hit the fast path. The fast path uses opengl to draw the buffer to the window back buffer, either by blitting or texturing. Then we track the region that was drawn, and when the draw ends we paint the normal cairo surface to the window (using texture-from-pixmap in the X11 case, or texture from cairo image otherwise) in the regions where there is no gl painted. There are some complexities wrt layering of gl and cairo areas though: * We track via gdk_window_mark_paint_from_clip() whenever gtk is painting over a region we previously rendered with opengl (flushed_region). This area (needs_blend_region) is blended rather than copied at the end of the frame. * If we're drawing a gl texture with alpha we first copy the current cairo_surface inside the target region to the back buffer before we blend over it. These two operations allow us full stacking of transparent gl and cairo regions.
2014-10-09 08:45:44 +00:00
*
docs: Rework the gdk docs Convert links, make things more concise.
2021-02-21 05:13:57 +00:00
* You will need to make the `GdkGLContext` the current context before issuing
* OpenGL calls; the system sends OpenGL commands to whichever context is current.
* It is possible to have multiple contexts, so you always need to ensure that
* the one which you want to draw with is the current one before issuing commands:
gdk: Add support for OpenGL This adds the new type GdkGLContext that wraps an OpenGL context for a particular native window. It also adds support for the gdk paint machinery to use OpenGL to draw everything. As soon as anyone creates a GL context for a native window we create a "paint context" for that GdkWindow and switch to using GL for painting it. This commit contains only an implementation for X11 (using GLX). The way painting works is that all client gl contexts draw into offscreen buffers rather than directly to the back buffer, and the way something gets onto the window is by using gdk_cairo_draw_from_gl() to draw part of that buffer onto the draw cairo context. As a fallback (if we're doing redirected drawing or some effect like a cairo_push_group()) we read back the gl buffer into memory and composite using cairo. This means that GL rendering works in all cases, including rendering to a PDF. However, this is not particularly fast. In the *typical* case, where we're drawing directly to the window in the regular paint loop we hit the fast path. The fast path uses opengl to draw the buffer to the window back buffer, either by blitting or texturing. Then we track the region that was drawn, and when the draw ends we paint the normal cairo surface to the window (using texture-from-pixmap in the X11 case, or texture from cairo image otherwise) in the regions where there is no gl painted. There are some complexities wrt layering of gl and cairo areas though: * We track via gdk_window_mark_paint_from_clip() whenever gtk is painting over a region we previously rendered with opengl (flushed_region). This area (needs_blend_region) is blended rather than copied at the end of the frame. * If we're drawing a gl texture with alpha we first copy the current cairo_surface inside the target region to the back buffer before we blend over it. These two operations allow us full stacking of transparent gl and cairo regions.
2014-10-09 08:45:44 +00:00
*
docs: Rework the gdk docs Convert links, make things more concise.
2021-02-21 05:13:57 +00:00
* ```c
* gdk_gl_context_make_current (context);
* ```
gdk: Add support for OpenGL This adds the new type GdkGLContext that wraps an OpenGL context for a particular native window. It also adds support for the gdk paint machinery to use OpenGL to draw everything. As soon as anyone creates a GL context for a native window we create a "paint context" for that GdkWindow and switch to using GL for painting it. This commit contains only an implementation for X11 (using GLX). The way painting works is that all client gl contexts draw into offscreen buffers rather than directly to the back buffer, and the way something gets onto the window is by using gdk_cairo_draw_from_gl() to draw part of that buffer onto the draw cairo context. As a fallback (if we're doing redirected drawing or some effect like a cairo_push_group()) we read back the gl buffer into memory and composite using cairo. This means that GL rendering works in all cases, including rendering to a PDF. However, this is not particularly fast. In the *typical* case, where we're drawing directly to the window in the regular paint loop we hit the fast path. The fast path uses opengl to draw the buffer to the window back buffer, either by blitting or texturing. Then we track the region that was drawn, and when the draw ends we paint the normal cairo surface to the window (using texture-from-pixmap in the X11 case, or texture from cairo image otherwise) in the regions where there is no gl painted. There are some complexities wrt layering of gl and cairo areas though: * We track via gdk_window_mark_paint_from_clip() whenever gtk is painting over a region we previously rendered with opengl (flushed_region). This area (needs_blend_region) is blended rather than copied at the end of the frame. * If we're drawing a gl texture with alpha we first copy the current cairo_surface inside the target region to the back buffer before we blend over it. These two operations allow us full stacking of transparent gl and cairo regions.
2014-10-09 08:45:44 +00:00
*
* You can now perform your drawing using OpenGL commands.
*
docs: Rework the gdk docs Convert links, make things more concise.
2021-02-21 05:13:57 +00:00
* You can check which `GdkGLContext` is the current one by using
* [func@Gdk.GLContext.get_current]; you can also unset any `GdkGLContext`
* that is currently set by calling [func@Gdk.GLContext.clear_current].
Document more structs
2017-12-26 19:39:24 +00:00
*/
gdk: Add support for OpenGL This adds the new type GdkGLContext that wraps an OpenGL context for a particular native window. It also adds support for the gdk paint machinery to use OpenGL to draw everything. As soon as anyone creates a GL context for a native window we create a "paint context" for that GdkWindow and switch to using GL for painting it. This commit contains only an implementation for X11 (using GLX). The way painting works is that all client gl contexts draw into offscreen buffers rather than directly to the back buffer, and the way something gets onto the window is by using gdk_cairo_draw_from_gl() to draw part of that buffer onto the draw cairo context. As a fallback (if we're doing redirected drawing or some effect like a cairo_push_group()) we read back the gl buffer into memory and composite using cairo. This means that GL rendering works in all cases, including rendering to a PDF. However, this is not particularly fast. In the *typical* case, where we're drawing directly to the window in the regular paint loop we hit the fast path. The fast path uses opengl to draw the buffer to the window back buffer, either by blitting or texturing. Then we track the region that was drawn, and when the draw ends we paint the normal cairo surface to the window (using texture-from-pixmap in the X11 case, or texture from cairo image otherwise) in the regions where there is no gl painted. There are some complexities wrt layering of gl and cairo areas though: * We track via gdk_window_mark_paint_from_clip() whenever gtk is painting over a region we previously rendered with opengl (flushed_region). This area (needs_blend_region) is blended rather than copied at the end of the frame. * If we're drawing a gl texture with alpha we first copy the current cairo_surface inside the target region to the back buffer before we blend over it. These two operations allow us full stacking of transparent gl and cairo regions.
2014-10-09 08:45:44 +00:00
#include "config.h"
#include "gdkglcontextprivate.h"
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
Rename gdkdebug.h to gdkdebugprivate.h This is the naming convention for private headers.
2022-09-24 03:11:41 +00:00
#include "gdkdebugprivate.h"
gdk: Add support for OpenGL This adds the new type GdkGLContext that wraps an OpenGL context for a particular native window. It also adds support for the gdk paint machinery to use OpenGL to draw everything. As soon as anyone creates a GL context for a native window we create a "paint context" for that GdkWindow and switch to using GL for painting it. This commit contains only an implementation for X11 (using GLX). The way painting works is that all client gl contexts draw into offscreen buffers rather than directly to the back buffer, and the way something gets onto the window is by using gdk_cairo_draw_from_gl() to draw part of that buffer onto the draw cairo context. As a fallback (if we're doing redirected drawing or some effect like a cairo_push_group()) we read back the gl buffer into memory and composite using cairo. This means that GL rendering works in all cases, including rendering to a PDF. However, this is not particularly fast. In the *typical* case, where we're drawing directly to the window in the regular paint loop we hit the fast path. The fast path uses opengl to draw the buffer to the window back buffer, either by blitting or texturing. Then we track the region that was drawn, and when the draw ends we paint the normal cairo surface to the window (using texture-from-pixmap in the X11 case, or texture from cairo image otherwise) in the regions where there is no gl painted. There are some complexities wrt layering of gl and cairo areas though: * We track via gdk_window_mark_paint_from_clip() whenever gtk is painting over a region we previously rendered with opengl (flushed_region). This area (needs_blend_region) is blended rather than copied at the end of the frame. * If we're drawing a gl texture with alpha we first copy the current cairo_surface inside the target region to the back buffer before we blend over it. These two operations allow us full stacking of transparent gl and cairo regions.
2014-10-09 08:45:44 +00:00
#include "gdkdisplayprivate.h"
egl: Split out a function This makes no sense by itself, but we want to create the EGLImage at DmabufTexture construction so that we can actually reject dmabufs that we can't create EGLImages for. This will make it possible to bail when the stride limitation for AMD GPUs hits.
2023-12-17 08:56:42 +00:00
#include "gdkdmabufeglprivate.h"
gdkglcontext: Include gdkdmabuffourccprivate.h It includes a fallback list of fourccs. Otherwise we might miss some DRM_FORMAT definition.
2024-02-13 11:37:20 +00:00
#include "gdkdmabuffourccprivate.h"
memorytexture: Split out GdkMemoryFormat handling Also, now make gdk_memory_convert() the only conversion functions and allow conversions between any 2 formats by going via a float[4]. This could be optimized via fast-paths, but so far it isn't.
2021-09-22 00:01:41 +00:00
#include "gdkmemoryformatprivate.h"
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
#include "gdkmemorytextureprivate.h"
egl: Unify contexts Unify the X11 and Wayland EGL contexts. This is a bit ugly to implement, because I don't want to create an interface and I can't make them inherit from the same object, because one needs to inherit from X11GLContext and the other from WaylandGLContext. So we have to put the code in GdkGLContext and make sure non-EGL contexts can't accidentally run it. This is rather easy because we can just check for priv->egl_context != NULL.
2021-10-05 22:34:10 +00:00
#include "gdkprofilerprivate.h"
gdk: Introduce GdkGLVersion ... and use it. Makes the code simpler.
2023-04-25 17:17:07 +00:00
#include "gdkglversionprivate.h"
gl context: Add private dmabuf API Add API to import a dmabuf into a texture, and to export a texture to a dmabuf. All this is implemented using the relevant EGL and GL extensions.
2023-10-15 23:27:22 +00:00
#include "gdkdmabufformatsprivate.h"
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
Rename gdk-private.h to gdkprivate.h The extra - does not add any value.
2022-09-24 03:23:27 +00:00
#include "gdkprivate.h"
gdk: Add support for OpenGL This adds the new type GdkGLContext that wraps an OpenGL context for a particular native window. It also adds support for the gdk paint machinery to use OpenGL to draw everything. As soon as anyone creates a GL context for a native window we create a "paint context" for that GdkWindow and switch to using GL for painting it. This commit contains only an implementation for X11 (using GLX). The way painting works is that all client gl contexts draw into offscreen buffers rather than directly to the back buffer, and the way something gets onto the window is by using gdk_cairo_draw_from_gl() to draw part of that buffer onto the draw cairo context. As a fallback (if we're doing redirected drawing or some effect like a cairo_push_group()) we read back the gl buffer into memory and composite using cairo. This means that GL rendering works in all cases, including rendering to a PDF. However, this is not particularly fast. In the *typical* case, where we're drawing directly to the window in the regular paint loop we hit the fast path. The fast path uses opengl to draw the buffer to the window back buffer, either by blitting or texturing. Then we track the region that was drawn, and when the draw ends we paint the normal cairo surface to the window (using texture-from-pixmap in the X11 case, or texture from cairo image otherwise) in the regions where there is no gl painted. There are some complexities wrt layering of gl and cairo areas though: * We track via gdk_window_mark_paint_from_clip() whenever gtk is painting over a region we previously rendered with opengl (flushed_region). This area (needs_blend_region) is blended rather than copied at the end of the frame. * If we're drawing a gl texture with alpha we first copy the current cairo_surface inside the target region to the back buffer before we blend over it. These two operations allow us full stacking of transparent gl and cairo regions.
2014-10-09 08:45:44 +00:00
egl: Split out a function This makes no sense by itself, but we want to create the EGLImage at DmabufTexture construction so that we can actually reject dmabufs that we can't create EGLImages for. This will make it possible to bail when the stride limitation for AMD GPUs hits.
2023-12-17 08:56:42 +00:00
#include <glib/gi18n-lib.h>
OpenGL/ES: Fix 'R' and 'B' bits inverted on Windows We need to use GL_BGRA instead of GL_RGBA when doing glReadPixels() on EGL on Windows (ANGLE) so that the red and blue bits won't be displayed inverted. Also fix the logic where we determine whether to bit blit or redraw everything.
2018-07-31 10:18:59 +00:00
#ifdef GDK_WINDOWING_WIN32
# include "gdk/win32/gdkwin32.h"
#endif
gdkglcontext: Track whether to use GL_TEXTURE_2D or GL_TEXTURE_RECTANGL_ARB
2014-10-27 20:12:40 +00:00
#include <epoxy/gl.h>
egl: Unify contexts Unify the X11 and Wayland EGL contexts. This is a bit ugly to implement, because I don't want to create an interface and I can't make them inherit from the same object, because one needs to inherit from X11GLContext and the other from WaylandGLContext. So we have to put the code in GdkGLContext and make sure non-EGL contexts can't accidentally run it. This is rather easy because we can just check for priv->egl_context != NULL.
2021-10-05 22:34:10 +00:00
#ifdef HAVE_EGL
#include <epoxy/egl.h>
#endif
gdkglcontext: Track whether to use GL_TEXTURE_2D or GL_TEXTURE_RECTANGL_ARB
2014-10-27 20:12:40 +00:00
Use fractional scale for the GL renderer This commit combines changes in the Wayland backend, the GL context frontend, and the GL renderer to switch them all to use the fractional scale. In the Wayland backend, we now use the fractional scale to size the EGL window. In the GL frontend code, we use the fractional scale to scale the damage region and surface in begin/end_frame. And in the GL renderer, we replace gdk_surface_get_scale_factor() with gdk_surface_get_scale().
2023-04-02 02:52:13 +00:00
#include <math.h>
glcontext: Add GdkGLContext::allowed-apis This allows specifying the GL APIs in a more comprehensive way than gdk_gl_context_set_use_es().
2021-10-07 15:59:17 +00:00
#define DEFAULT_ALLOWED_APIS GDK_GL_API_GL | GDK_GL_API_GLES
glcontext: Add gdk_gl_context_get_memory_flags() Checks which features of a given memory format are supported by the current GL implementation. We check: * usable: Can be used as a texture with NEAREST filter * renderable: Can be used as a render target * filterable: Can be used with GL_LINEAR In normal GL, all formats are all of these things, but GLES is a lot more picky. So far nobody uses this.
2023-12-07 04:45:59 +00:00
typedef struct _GdkGLContextPrivate GdkGLContextPrivate;
struct _GdkGLContextPrivate
{
gdk: Introduce GdkGLVersion ... and use it. Makes the code simpler.
2023-04-25 17:17:07 +00:00
GdkGLVersion required;
glcontext: Use GdkGLVersion elsewhere ... and add a convenience API to generate GL versions from strings to make the gdk_gl_context_check() API nicer.
2023-04-25 17:32:12 +00:00
GdkGLVersion gl_version;
gl: Add context options Users of the GdkGLContext API should be allowed to set properties on the shim GdkGLContext instance prior to realization, so that the backend-specific implementation can use the value of those properties when creating the windowing system specific resources. The main three options are: • a major/minor version tuple, to request a specific GL version • a debug bit, to request a "debug context", which provides additional validation and run time checking • a forward compatibility bit, to request a context that does not have deprecated functionality See also: - https://www.opengl.org/registry/specs/ARB/glx_create_context.txt https://bugzilla.gnome.org/show_bug.cgi?id=741946
2015-01-28 09:34:16 +00:00
glcontext: Add gdk_gl_context_get_memory_flags() Checks which features of a given memory format are supported by the current GL implementation. We check: * usable: Can be used as a texture with NEAREST filter * renderable: Can be used as a render target * filterable: Can be used with GL_LINEAR In normal GL, all formats are all of these things, but GLES is a lot more picky. So far nobody uses this.
2023-12-07 04:45:59 +00:00
GdkGLMemoryFlags memory_flags[GDK_MEMORY_N_FORMATS];
GdkGLContext: Add internal functions for KHR_DEBUG calls This includes pushing and poping debug group messages and labeling objects.
2019-04-24 11:25:46 +00:00
guint has_khr_debug : 1;
gdkglcontext: Only emit opengl debug calls if GDK_DEBUG=gl-debug This avoids a potential performance cost in the non-debug case.
2019-04-24 13:23:32 +00:00
guint use_khr_debug : 1;
gdk: Check OES_vertex_half_float GLES extension This will be checked in the GL renderer.
2022-05-05 17:08:32 +00:00
guint has_half_float : 1;
glcontext: Add a way to check for GLsync
2023-04-26 09:59:51 +00:00
guint has_sync : 1;
gl: Add more OpenGL ES checks Check for the appropriate extensions depending on which type of API we're using.
2016-04-22 16:27:04 +00:00
guint has_unpack_subimage : 1;
GdkGLContext: Add a GL debug message callback If G_ENABLE_CONSISTENCY_CHECKS is defined (i.e. if our buildtype is 'debug'), add a opengl debug callback that prints all debug messages with a severity higher than SEVERITY_NOTIFICATION as a warning to the console.
2018-03-25 13:28:40 +00:00
guint has_debug_output : 1;
glcontext: Check for GL_EXT_texture_format_BGRA8888 Check for this GLES extension and add a private getter.
2023-10-19 17:54:14 +00:00
guint has_bgra : 1;
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
guint extensions_checked : 1;
gl: Add context options Users of the GdkGLContext API should be allowed to set properties on the shim GdkGLContext instance prior to realization, so that the backend-specific implementation can use the value of those properties when creating the windowing system specific resources. The main three options are: • a major/minor version tuple, to request a specific GL version • a debug bit, to request a "debug context", which provides additional validation and run time checking • a forward compatibility bit, to request a context that does not have deprecated functionality See also: - https://www.opengl.org/registry/specs/ARB/glx_create_context.txt https://bugzilla.gnome.org/show_bug.cgi?id=741946
2015-01-28 09:34:16 +00:00
guint debug_enabled : 1;
guint forward_compatible : 1;
gdk: Allow querying if a GL context is in legacy mode We want to have the ability to fall back to legacy GL contexts when creating them. In order to do so, we need to store the legacy bit on the GdkGLContext, as well as being able to query it. Setting the legacy bit from outside GDK is not possible; we cannot create GL contexts in 3.2 core profile *and* compatibility modes at the same time, and if we allowed users to select the legacy mode themselves, it would break the creation of the GdkWindow's paint GL context. What we do allow is falling back to legacy GL context if the platform does not support 3.2 core profiles — for instance, on older GPUs or inside virtualized environments. We are also going to use the legacy bit internally, to choose which GL API we can use when drawing GL content. https://bugzilla.gnome.org/show_bug.cgi?id=756142
2015-10-06 17:54:58 +00:00
guint is_legacy : 1;
gdk/gl: Allow autodetection for GL/GLES If the GdkGLContext was not explicitly instructed to use or not GLES, we can detect whether the underlying API is going to be desktop GL or GLES. https://bugzilla.gnome.org/show_bug.cgi?id=773180
2016-10-19 12:43:17 +00:00
glcontext: Add GdkGLContext::allowed-apis This allows specifying the GL APIs in a more comprehensive way than gdk_gl_context_set_use_es().
2021-10-07 15:59:17 +00:00
GdkGLAPI allowed_apis;
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;
gdkglcontext: Track whether to use GL_TEXTURE_2D or GL_TEXTURE_RECTANGL_ARB
2014-10-27 20:12:40 +00:00
gdkglcontext: Limit gl debug label length There's a maximum length we have to adhere to, otherwise GL throws a GL_INVALID_VALUE error.
2019-04-27 07:49:41 +00:00
int max_debug_label_length;
egl: Unify contexts Unify the X11 and Wayland EGL contexts. This is a bit ugly to implement, because I don't want to create an interface and I can't make them inherit from the same object, because one needs to inherit from X11GLContext and the other from WaylandGLContext. So we have to put the code in GdkGLContext and make sure non-EGL contexts can't accidentally run it. This is rather easy because we can just check for priv->egl_context != NULL.
2021-10-05 22:34:10 +00:00
#ifdef HAVE_EGL
EGLContext egl_context;
gdk: use EGL_KHR_swap_buffers_with_damage It appears that NVIDIA does not implement EGL_EXT_swap_buffers_with_damage on their EGL implementation, but does implement the KHR variant of it. This checks for a suitable implementation and stores a pointer to the compatible implementation within the GdkGLContextPrivate struct.
2022-03-03 06:59:23 +00:00
EGLBoolean (*eglSwapBuffersWithDamage) (EGLDisplay, EGLSurface, const EGLint *, EGLint);
egl: Unify contexts Unify the X11 and Wayland EGL contexts. This is a bit ugly to implement, because I don't want to create an interface and I can't make them inherit from the same object, because one needs to inherit from X11GLContext and the other from WaylandGLContext. So we have to put the code in GdkGLContext and make sure non-EGL contexts can't accidentally run it. This is rather easy because we can just check for priv->egl_context != NULL.
2021-10-05 22:34:10 +00:00
#endif
glcontext: Add gdk_gl_context_get_memory_flags() Checks which features of a given memory format are supported by the current GL implementation. We check: * usable: Can be used as a texture with NEAREST filter * renderable: Can be used as a render target * filterable: Can be used with GL_LINEAR In normal GL, all formats are all of these things, but GLES is a lot more picky. So far nobody uses this.
2023-12-07 04:45:59 +00:00
};
gdk: Add support for OpenGL This adds the new type GdkGLContext that wraps an OpenGL context for a particular native window. It also adds support for the gdk paint machinery to use OpenGL to draw everything. As soon as anyone creates a GL context for a native window we create a "paint context" for that GdkWindow and switch to using GL for painting it. This commit contains only an implementation for X11 (using GLX). The way painting works is that all client gl contexts draw into offscreen buffers rather than directly to the back buffer, and the way something gets onto the window is by using gdk_cairo_draw_from_gl() to draw part of that buffer onto the draw cairo context. As a fallback (if we're doing redirected drawing or some effect like a cairo_push_group()) we read back the gl buffer into memory and composite using cairo. This means that GL rendering works in all cases, including rendering to a PDF. However, this is not particularly fast. In the *typical* case, where we're drawing directly to the window in the regular paint loop we hit the fast path. The fast path uses opengl to draw the buffer to the window back buffer, either by blitting or texturing. Then we track the region that was drawn, and when the draw ends we paint the normal cairo surface to the window (using texture-from-pixmap in the X11 case, or texture from cairo image otherwise) in the regions where there is no gl painted. There are some complexities wrt layering of gl and cairo areas though: * We track via gdk_window_mark_paint_from_clip() whenever gtk is painting over a region we previously rendered with opengl (flushed_region). This area (needs_blend_region) is blended rather than copied at the end of the frame. * If we're drawing a gl texture with alpha we first copy the current cairo_surface inside the target region to the back buffer before we blend over it. These two operations allow us full stacking of transparent gl and cairo regions.
2014-10-09 08:45:44 +00:00
enum {
PROP_0,
glcontext: Add GdkGLContext::allowed-apis This allows specifying the GL APIs in a more comprehensive way than gdk_gl_context_set_use_es().
2021-10-07 15:59:17 +00:00
PROP_ALLOWED_APIS,
glcontext: Add gdk_gl_context_get_api() This is mostly for inspector. Not sure if we also want to deprecate gdk_gl_context_get_use_es() in favor of this function.
2021-10-07 21:03:45 +00:00
PROP_API,
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
PROP_SHARED_CONTEXT,
gdk: Add support for OpenGL This adds the new type GdkGLContext that wraps an OpenGL context for a particular native window. It also adds support for the gdk paint machinery to use OpenGL to draw everything. As soon as anyone creates a GL context for a native window we create a "paint context" for that GdkWindow and switch to using GL for painting it. This commit contains only an implementation for X11 (using GLX). The way painting works is that all client gl contexts draw into offscreen buffers rather than directly to the back buffer, and the way something gets onto the window is by using gdk_cairo_draw_from_gl() to draw part of that buffer onto the draw cairo context. As a fallback (if we're doing redirected drawing or some effect like a cairo_push_group()) we read back the gl buffer into memory and composite using cairo. This means that GL rendering works in all cases, including rendering to a PDF. However, this is not particularly fast. In the *typical* case, where we're drawing directly to the window in the regular paint loop we hit the fast path. The fast path uses opengl to draw the buffer to the window back buffer, either by blitting or texturing. Then we track the region that was drawn, and when the draw ends we paint the normal cairo surface to the window (using texture-from-pixmap in the X11 case, or texture from cairo image otherwise) in the regions where there is no gl painted. There are some complexities wrt layering of gl and cairo areas though: * We track via gdk_window_mark_paint_from_clip() whenever gtk is painting over a region we previously rendered with opengl (flushed_region). This area (needs_blend_region) is blended rather than copied at the end of the frame. * If we're drawing a gl texture with alpha we first copy the current cairo_surface inside the target region to the back buffer before we blend over it. These two operations allow us full stacking of transparent gl and cairo regions.
2014-10-09 08:45:44 +00:00
LAST_PROP
};
glcontext: Add GdkGLContext::allowed-apis This allows specifying the GL APIs in a more comprehensive way than gdk_gl_context_set_use_es().
2021-10-07 15:59:17 +00:00
static GParamSpec *properties[LAST_PROP] = { NULL, };
gdk: Add support for OpenGL This adds the new type GdkGLContext that wraps an OpenGL context for a particular native window. It also adds support for the gdk paint machinery to use OpenGL to draw everything. As soon as anyone creates a GL context for a native window we create a "paint context" for that GdkWindow and switch to using GL for painting it. This commit contains only an implementation for X11 (using GLX). The way painting works is that all client gl contexts draw into offscreen buffers rather than directly to the back buffer, and the way something gets onto the window is by using gdk_cairo_draw_from_gl() to draw part of that buffer onto the draw cairo context. As a fallback (if we're doing redirected drawing or some effect like a cairo_push_group()) we read back the gl buffer into memory and composite using cairo. This means that GL rendering works in all cases, including rendering to a PDF. However, this is not particularly fast. In the *typical* case, where we're drawing directly to the window in the regular paint loop we hit the fast path. The fast path uses opengl to draw the buffer to the window back buffer, either by blitting or texturing. Then we track the region that was drawn, and when the draw ends we paint the normal cairo surface to the window (using texture-from-pixmap in the X11 case, or texture from cairo image otherwise) in the regions where there is no gl painted. There are some complexities wrt layering of gl and cairo areas though: * We track via gdk_window_mark_paint_from_clip() whenever gtk is painting over a region we previously rendered with opengl (flushed_region). This area (needs_blend_region) is blended rather than copied at the end of the frame. * If we're drawing a gl texture with alpha we first copy the current cairo_surface inside the target region to the back buffer before we blend over it. These two operations allow us full stacking of transparent gl and cairo regions.
2014-10-09 08:45:44 +00:00
G_DEFINE_QUARK (gdk-gl-error-quark, gdk_gl_error)
gdk: Turn GdkGLContext into a GdkDrawContext
2016-11-28 16:36:37 +00:00
G_DEFINE_ABSTRACT_TYPE_WITH_PRIVATE (GdkGLContext, gdk_gl_context, GDK_TYPE_DRAW_CONTEXT)
gdk: Add support for OpenGL This adds the new type GdkGLContext that wraps an OpenGL context for a particular native window. It also adds support for the gdk paint machinery to use OpenGL to draw everything. As soon as anyone creates a GL context for a native window we create a "paint context" for that GdkWindow and switch to using GL for painting it. This commit contains only an implementation for X11 (using GLX). The way painting works is that all client gl contexts draw into offscreen buffers rather than directly to the back buffer, and the way something gets onto the window is by using gdk_cairo_draw_from_gl() to draw part of that buffer onto the draw cairo context. As a fallback (if we're doing redirected drawing or some effect like a cairo_push_group()) we read back the gl buffer into memory and composite using cairo. This means that GL rendering works in all cases, including rendering to a PDF. However, this is not particularly fast. In the *typical* case, where we're drawing directly to the window in the regular paint loop we hit the fast path. The fast path uses opengl to draw the buffer to the window back buffer, either by blitting or texturing. Then we track the region that was drawn, and when the draw ends we paint the normal cairo surface to the window (using texture-from-pixmap in the X11 case, or texture from cairo image otherwise) in the regions where there is no gl painted. There are some complexities wrt layering of gl and cairo areas though: * We track via gdk_window_mark_paint_from_clip() whenever gtk is painting over a region we previously rendered with opengl (flushed_region). This area (needs_blend_region) is blended rather than copied at the end of the frame. * If we're drawing a gl texture with alpha we first copy the current cairo_surface inside the target region to the back buffer before we blend over it. These two operations allow us full stacking of transparent gl and cairo regions.
2014-10-09 08:45:44 +00:00
gl: Store the context::in-frame state in the current context Do not treat the context as already current when the value of context::in-frame changes. This is so we can bind to EGL_NO_SURFACE if context::in-frame == false and to context::surface if context::in-frame == true. This allows getting rid of the attached property in future commits.
2021-07-06 02:47:15 +00:00
typedef struct _MaskedContext MaskedContext;
static inline MaskedContext *
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
mask_context (GdkGLContext *context,
gboolean surfaceless)
gl: Store the context::in-frame state in the current context Do not treat the context as already current when the value of context::in-frame changes. This is so we can bind to EGL_NO_SURFACE if context::in-frame == false and to context::surface if context::in-frame == true. This allows getting rid of the attached property in future commits.
2021-07-06 02:47:15 +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
return (MaskedContext *) GSIZE_TO_POINTER (GPOINTER_TO_SIZE (context) | (surfaceless ? 1 : 0));
gl: Store the context::in-frame state in the current context Do not treat the context as already current when the value of context::in-frame changes. This is so we can bind to EGL_NO_SURFACE if context::in-frame == false and to context::surface if context::in-frame == true. This allows getting rid of the attached property in future commits.
2021-07-06 02:47:15 +00:00
}
static inline GdkGLContext *
unmask_context (MaskedContext *mask)
{
return GDK_GL_CONTEXT (GSIZE_TO_POINTER (GPOINTER_TO_SIZE (mask) & ~(gsize) 1));
}
gl: Clear current when destroying current's surface When destroying the EGLSurface or GLXDrawable of a GdkSurface, make sure the current context is not still bound to it. If it is, clear the current context. Fixes #4554
2021-12-22 18:49:13 +00:00
static inline gboolean
mask_is_surfaceless (MaskedContext *mask)
{
return GPOINTER_TO_SIZE (mask) & (gsize) 1;
}
gl: Store the context::in-frame state in the current context Do not treat the context as already current when the value of context::in-frame changes. This is so we can bind to EGL_NO_SURFACE if context::in-frame == false and to context::surface if context::in-frame == true. This allows getting rid of the attached property in future commits.
2021-07-06 02:47:15 +00:00
static void
unref_unmasked (gpointer data)
{
g_object_unref (unmask_context (data));
}
static GPrivate thread_current_context = G_PRIVATE_INIT (unref_unmasked);
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
glcontext: Store the buffer age regions in the GL context That way, we can store the right region there: The actual painted area instead of the exposed area (which is way too small). Also, the GL context is the only user of this data, so storing it there seems way smarter.
2018-04-08 22:58:31 +00:00
static void
gdk_gl_context_clear_old_updated_area (GdkGLContext *context)
{
gl: Free all tracked buffers This was overlooked when the number of tracked buffers was bumped from 2 to 4 in 46e3454eb7730e4.
2023-06-05 02:17:56 +00:00
for (unsigned int i = 0; i < GDK_GL_MAX_TRACKED_BUFFERS; i++)
g_clear_pointer (&context->old_updated_area[i], cairo_region_destroy);
glcontext: Store the buffer age regions in the GL context That way, we can store the right region there: The actual painted area instead of the exposed area (which is way too small). Also, the GL context is the only user of this data, so storing it there seems way smarter.
2018-04-08 22:58:31 +00:00
}
gdk: Add support for OpenGL This adds the new type GdkGLContext that wraps an OpenGL context for a particular native window. It also adds support for the gdk paint machinery to use OpenGL to draw everything. As soon as anyone creates a GL context for a native window we create a "paint context" for that GdkWindow and switch to using GL for painting it. This commit contains only an implementation for X11 (using GLX). The way painting works is that all client gl contexts draw into offscreen buffers rather than directly to the back buffer, and the way something gets onto the window is by using gdk_cairo_draw_from_gl() to draw part of that buffer onto the draw cairo context. As a fallback (if we're doing redirected drawing or some effect like a cairo_push_group()) we read back the gl buffer into memory and composite using cairo. This means that GL rendering works in all cases, including rendering to a PDF. However, this is not particularly fast. In the *typical* case, where we're drawing directly to the window in the regular paint loop we hit the fast path. The fast path uses opengl to draw the buffer to the window back buffer, either by blitting or texturing. Then we track the region that was drawn, and when the draw ends we paint the normal cairo surface to the window (using texture-from-pixmap in the X11 case, or texture from cairo image otherwise) in the regions where there is no gl painted. There are some complexities wrt layering of gl and cairo areas though: * We track via gdk_window_mark_paint_from_clip() whenever gtk is painting over a region we previously rendered with opengl (flushed_region). This area (needs_blend_region) is blended rather than copied at the end of the frame. * If we're drawing a gl texture with alpha we first copy the current cairo_surface inside the target region to the back buffer before we blend over it. These two operations allow us full stacking of transparent gl and cairo regions.
2014-10-09 08:45:44 +00:00
static void
gdk_gl_context_dispose (GObject *gobject)
{
GdkGLContext *context = GDK_GL_CONTEXT (gobject);
egl: Unify contexts Unify the X11 and Wayland EGL contexts. This is a bit ugly to implement, because I don't want to create an interface and I can't make them inherit from the same object, because one needs to inherit from X11GLContext and the other from WaylandGLContext. So we have to put the code in GdkGLContext and make sure non-EGL contexts can't accidentally run it. This is rather easy because we can just check for priv->egl_context != NULL.
2021-10-05 22:34:10 +00:00
#ifdef HAVE_EGL
GdkGLContextPrivate *priv = gdk_gl_context_get_instance_private (context);
if (priv->egl_context != NULL)
{
glcontext: Don't spew warnings on surfaceless contexts Get the display directly instead of via the nonexisting surface.
2022-01-06 18:23:29 +00:00
GdkDisplay *display = gdk_draw_context_get_display (GDK_DRAW_CONTEXT (context));
egl: Unify contexts Unify the X11 and Wayland EGL contexts. This is a bit ugly to implement, because I don't want to create an interface and I can't make them inherit from the same object, because one needs to inherit from X11GLContext and the other from WaylandGLContext. So we have to put the code in GdkGLContext and make sure non-EGL contexts can't accidentally run it. This is rather easy because we can just check for priv->egl_context != NULL.
2021-10-05 22:34:10 +00:00
EGLDisplay *egl_display = gdk_display_get_egl_display (display);
if (eglGetCurrentContext () == priv->egl_context)
eglMakeCurrent(egl_display, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT);
gdk: Use the new debug macros
2022-09-23 00:48:58 +00:00
GDK_DISPLAY_DEBUG (display, OPENGL, "Destroying EGL context");
egl: Unify contexts Unify the X11 and Wayland EGL contexts. This is a bit ugly to implement, because I don't want to create an interface and I can't make them inherit from the same object, because one needs to inherit from X11GLContext and the other from WaylandGLContext. So we have to put the code in GdkGLContext and make sure non-EGL contexts can't accidentally run it. This is rather easy because we can just check for priv->egl_context != NULL.
2021-10-05 22:34:10 +00:00
eglDestroyContext (egl_display, priv->egl_context);
priv->egl_context = NULL;
}
#endif
gdk: Add support for OpenGL This adds the new type GdkGLContext that wraps an OpenGL context for a particular native window. It also adds support for the gdk paint machinery to use OpenGL to draw everything. As soon as anyone creates a GL context for a native window we create a "paint context" for that GdkWindow and switch to using GL for painting it. This commit contains only an implementation for X11 (using GLX). The way painting works is that all client gl contexts draw into offscreen buffers rather than directly to the back buffer, and the way something gets onto the window is by using gdk_cairo_draw_from_gl() to draw part of that buffer onto the draw cairo context. As a fallback (if we're doing redirected drawing or some effect like a cairo_push_group()) we read back the gl buffer into memory and composite using cairo. This means that GL rendering works in all cases, including rendering to a PDF. However, this is not particularly fast. In the *typical* case, where we're drawing directly to the window in the regular paint loop we hit the fast path. The fast path uses opengl to draw the buffer to the window back buffer, either by blitting or texturing. Then we track the region that was drawn, and when the draw ends we paint the normal cairo surface to the window (using texture-from-pixmap in the X11 case, or texture from cairo image otherwise) in the regions where there is no gl painted. There are some complexities wrt layering of gl and cairo areas though: * We track via gdk_window_mark_paint_from_clip() whenever gtk is painting over a region we previously rendered with opengl (flushed_region). This area (needs_blend_region) is blended rather than copied at the end of the frame. * If we're drawing a gl texture with alpha we first copy the current cairo_surface inside the target region to the back buffer before we blend over it. These two operations allow us full stacking of transparent gl and cairo regions.
2014-10-09 08:45:44 +00:00
glcontext: Store the buffer age regions in the GL context That way, we can store the right region there: The actual painted area instead of the exposed area (which is way too small). Also, the GL context is the only user of this data, so storing it there seems way smarter.
2018-04-08 22:58:31 +00:00
gdk_gl_context_clear_old_updated_area (context);
gdk: Add support for OpenGL This adds the new type GdkGLContext that wraps an OpenGL context for a particular native window. It also adds support for the gdk paint machinery to use OpenGL to draw everything. As soon as anyone creates a GL context for a native window we create a "paint context" for that GdkWindow and switch to using GL for painting it. This commit contains only an implementation for X11 (using GLX). The way painting works is that all client gl contexts draw into offscreen buffers rather than directly to the back buffer, and the way something gets onto the window is by using gdk_cairo_draw_from_gl() to draw part of that buffer onto the draw cairo context. As a fallback (if we're doing redirected drawing or some effect like a cairo_push_group()) we read back the gl buffer into memory and composite using cairo. This means that GL rendering works in all cases, including rendering to a PDF. However, this is not particularly fast. In the *typical* case, where we're drawing directly to the window in the regular paint loop we hit the fast path. The fast path uses opengl to draw the buffer to the window back buffer, either by blitting or texturing. Then we track the region that was drawn, and when the draw ends we paint the normal cairo surface to the window (using texture-from-pixmap in the X11 case, or texture from cairo image otherwise) in the regions where there is no gl painted. There are some complexities wrt layering of gl and cairo areas though: * We track via gdk_window_mark_paint_from_clip() whenever gtk is painting over a region we previously rendered with opengl (flushed_region). This area (needs_blend_region) is blended rather than copied at the end of the frame. * If we're drawing a gl texture with alpha we first copy the current cairo_surface inside the target region to the back buffer before we blend over it. These two operations allow us full stacking of transparent gl and cairo regions.
2014-10-09 08:45:44 +00:00
G_OBJECT_CLASS (gdk_gl_context_parent_class)->dispose (gobject);
}
static void
glcontext: Add GdkGLContext::allowed-apis This allows specifying the GL APIs in a more comprehensive way than gdk_gl_context_set_use_es().
2021-10-07 15:59:17 +00:00
gdk_gl_context_set_property (GObject *object,
gdk: Add support for OpenGL This adds the new type GdkGLContext that wraps an OpenGL context for a particular native window. It also adds support for the gdk paint machinery to use OpenGL to draw everything. As soon as anyone creates a GL context for a native window we create a "paint context" for that GdkWindow and switch to using GL for painting it. This commit contains only an implementation for X11 (using GLX). The way painting works is that all client gl contexts draw into offscreen buffers rather than directly to the back buffer, and the way something gets onto the window is by using gdk_cairo_draw_from_gl() to draw part of that buffer onto the draw cairo context. As a fallback (if we're doing redirected drawing or some effect like a cairo_push_group()) we read back the gl buffer into memory and composite using cairo. This means that GL rendering works in all cases, including rendering to a PDF. However, this is not particularly fast. In the *typical* case, where we're drawing directly to the window in the regular paint loop we hit the fast path. The fast path uses opengl to draw the buffer to the window back buffer, either by blitting or texturing. Then we track the region that was drawn, and when the draw ends we paint the normal cairo surface to the window (using texture-from-pixmap in the X11 case, or texture from cairo image otherwise) in the regions where there is no gl painted. There are some complexities wrt layering of gl and cairo areas though: * We track via gdk_window_mark_paint_from_clip() whenever gtk is painting over a region we previously rendered with opengl (flushed_region). This area (needs_blend_region) is blended rather than copied at the end of the frame. * If we're drawing a gl texture with alpha we first copy the current cairo_surface inside the target region to the back buffer before we blend over it. These two operations allow us full stacking of transparent gl and cairo regions.
2014-10-09 08:45:44 +00:00
guint prop_id,
const GValue *value,
GParamSpec *pspec)
{
glcontext: Add GdkGLContext::allowed-apis This allows specifying the GL APIs in a more comprehensive way than gdk_gl_context_set_use_es().
2021-10-07 15:59:17 +00:00
GdkGLContext *self = GDK_GL_CONTEXT (object);
gdk: Add support for OpenGL This adds the new type GdkGLContext that wraps an OpenGL context for a particular native window. It also adds support for the gdk paint machinery to use OpenGL to draw everything. As soon as anyone creates a GL context for a native window we create a "paint context" for that GdkWindow and switch to using GL for painting it. This commit contains only an implementation for X11 (using GLX). The way painting works is that all client gl contexts draw into offscreen buffers rather than directly to the back buffer, and the way something gets onto the window is by using gdk_cairo_draw_from_gl() to draw part of that buffer onto the draw cairo context. As a fallback (if we're doing redirected drawing or some effect like a cairo_push_group()) we read back the gl buffer into memory and composite using cairo. This means that GL rendering works in all cases, including rendering to a PDF. However, this is not particularly fast. In the *typical* case, where we're drawing directly to the window in the regular paint loop we hit the fast path. The fast path uses opengl to draw the buffer to the window back buffer, either by blitting or texturing. Then we track the region that was drawn, and when the draw ends we paint the normal cairo surface to the window (using texture-from-pixmap in the X11 case, or texture from cairo image otherwise) in the regions where there is no gl painted. There are some complexities wrt layering of gl and cairo areas though: * We track via gdk_window_mark_paint_from_clip() whenever gtk is painting over a region we previously rendered with opengl (flushed_region). This area (needs_blend_region) is blended rather than copied at the end of the frame. * If we're drawing a gl texture with alpha we first copy the current cairo_surface inside the target region to the back buffer before we blend over it. These two operations allow us full stacking of transparent gl and cairo regions.
2014-10-09 08:45:44 +00:00
switch (prop_id)
{
glcontext: Add GdkGLContext::allowed-apis This allows specifying the GL APIs in a more comprehensive way than gdk_gl_context_set_use_es().
2021-10-07 15:59:17 +00:00
case PROP_ALLOWED_APIS:
gdk_gl_context_set_allowed_apis (self, g_value_get_flags (value));
break;
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
case PROP_SHARED_CONTEXT:
gl: Deprecate gdk_gl_context_get_shared_context() It's not used anymore. And in particular we do want to keep the display context private, so we're not gonna return it from this function.
2021-07-10 01:24:00 +00:00
g_assert (g_value_get_object (value) == NULL);
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
break;
gdk: Add support for OpenGL This adds the new type GdkGLContext that wraps an OpenGL context for a particular native window. It also adds support for the gdk paint machinery to use OpenGL to draw everything. As soon as anyone creates a GL context for a native window we create a "paint context" for that GdkWindow and switch to using GL for painting it. This commit contains only an implementation for X11 (using GLX). The way painting works is that all client gl contexts draw into offscreen buffers rather than directly to the back buffer, and the way something gets onto the window is by using gdk_cairo_draw_from_gl() to draw part of that buffer onto the draw cairo context. As a fallback (if we're doing redirected drawing or some effect like a cairo_push_group()) we read back the gl buffer into memory and composite using cairo. This means that GL rendering works in all cases, including rendering to a PDF. However, this is not particularly fast. In the *typical* case, where we're drawing directly to the window in the regular paint loop we hit the fast path. The fast path uses opengl to draw the buffer to the window back buffer, either by blitting or texturing. Then we track the region that was drawn, and when the draw ends we paint the normal cairo surface to the window (using texture-from-pixmap in the X11 case, or texture from cairo image otherwise) in the regions where there is no gl painted. There are some complexities wrt layering of gl and cairo areas though: * We track via gdk_window_mark_paint_from_clip() whenever gtk is painting over a region we previously rendered with opengl (flushed_region). This area (needs_blend_region) is blended rather than copied at the end of the frame. * If we're drawing a gl texture with alpha we first copy the current cairo_surface inside the target region to the back buffer before we blend over it. These two operations allow us full stacking of transparent gl and cairo regions.
2014-10-09 08:45:44 +00:00
default:
glcontext: Add GdkGLContext::allowed-apis This allows specifying the GL APIs in a more comprehensive way than gdk_gl_context_set_use_es().
2021-10-07 15:59:17 +00:00
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
gdk: Add support for OpenGL This adds the new type GdkGLContext that wraps an OpenGL context for a particular native window. It also adds support for the gdk paint machinery to use OpenGL to draw everything. As soon as anyone creates a GL context for a native window we create a "paint context" for that GdkWindow and switch to using GL for painting it. This commit contains only an implementation for X11 (using GLX). The way painting works is that all client gl contexts draw into offscreen buffers rather than directly to the back buffer, and the way something gets onto the window is by using gdk_cairo_draw_from_gl() to draw part of that buffer onto the draw cairo context. As a fallback (if we're doing redirected drawing or some effect like a cairo_push_group()) we read back the gl buffer into memory and composite using cairo. This means that GL rendering works in all cases, including rendering to a PDF. However, this is not particularly fast. In the *typical* case, where we're drawing directly to the window in the regular paint loop we hit the fast path. The fast path uses opengl to draw the buffer to the window back buffer, either by blitting or texturing. Then we track the region that was drawn, and when the draw ends we paint the normal cairo surface to the window (using texture-from-pixmap in the X11 case, or texture from cairo image otherwise) in the regions where there is no gl painted. There are some complexities wrt layering of gl and cairo areas though: * We track via gdk_window_mark_paint_from_clip() whenever gtk is painting over a region we previously rendered with opengl (flushed_region). This area (needs_blend_region) is blended rather than copied at the end of the frame. * If we're drawing a gl texture with alpha we first copy the current cairo_surface inside the target region to the back buffer before we blend over it. These two operations allow us full stacking of transparent gl and cairo regions.
2014-10-09 08:45:44 +00:00
}
}
static void
glcontext: Add GdkGLContext::allowed-apis This allows specifying the GL APIs in a more comprehensive way than gdk_gl_context_set_use_es().
2021-10-07 15:59:17 +00:00
gdk_gl_context_get_property (GObject *object,
gdk: Add support for OpenGL This adds the new type GdkGLContext that wraps an OpenGL context for a particular native window. It also adds support for the gdk paint machinery to use OpenGL to draw everything. As soon as anyone creates a GL context for a native window we create a "paint context" for that GdkWindow and switch to using GL for painting it. This commit contains only an implementation for X11 (using GLX). The way painting works is that all client gl contexts draw into offscreen buffers rather than directly to the back buffer, and the way something gets onto the window is by using gdk_cairo_draw_from_gl() to draw part of that buffer onto the draw cairo context. As a fallback (if we're doing redirected drawing or some effect like a cairo_push_group()) we read back the gl buffer into memory and composite using cairo. This means that GL rendering works in all cases, including rendering to a PDF. However, this is not particularly fast. In the *typical* case, where we're drawing directly to the window in the regular paint loop we hit the fast path. The fast path uses opengl to draw the buffer to the window back buffer, either by blitting or texturing. Then we track the region that was drawn, and when the draw ends we paint the normal cairo surface to the window (using texture-from-pixmap in the X11 case, or texture from cairo image otherwise) in the regions where there is no gl painted. There are some complexities wrt layering of gl and cairo areas though: * We track via gdk_window_mark_paint_from_clip() whenever gtk is painting over a region we previously rendered with opengl (flushed_region). This area (needs_blend_region) is blended rather than copied at the end of the frame. * If we're drawing a gl texture with alpha we first copy the current cairo_surface inside the target region to the back buffer before we blend over it. These two operations allow us full stacking of transparent gl and cairo regions.
2014-10-09 08:45:44 +00:00
guint prop_id,
GValue *value,
GParamSpec *pspec)
{
glcontext: Add GdkGLContext::allowed-apis This allows specifying the GL APIs in a more comprehensive way than gdk_gl_context_set_use_es().
2021-10-07 15:59:17 +00:00
GdkGLContext *self = GDK_GL_CONTEXT (object);
GdkGLContextPrivate *priv = gdk_gl_context_get_instance_private (self);
gdk: Add support for OpenGL This adds the new type GdkGLContext that wraps an OpenGL context for a particular native window. It also adds support for the gdk paint machinery to use OpenGL to draw everything. As soon as anyone creates a GL context for a native window we create a "paint context" for that GdkWindow and switch to using GL for painting it. This commit contains only an implementation for X11 (using GLX). The way painting works is that all client gl contexts draw into offscreen buffers rather than directly to the back buffer, and the way something gets onto the window is by using gdk_cairo_draw_from_gl() to draw part of that buffer onto the draw cairo context. As a fallback (if we're doing redirected drawing or some effect like a cairo_push_group()) we read back the gl buffer into memory and composite using cairo. This means that GL rendering works in all cases, including rendering to a PDF. However, this is not particularly fast. In the *typical* case, where we're drawing directly to the window in the regular paint loop we hit the fast path. The fast path uses opengl to draw the buffer to the window back buffer, either by blitting or texturing. Then we track the region that was drawn, and when the draw ends we paint the normal cairo surface to the window (using texture-from-pixmap in the X11 case, or texture from cairo image otherwise) in the regions where there is no gl painted. There are some complexities wrt layering of gl and cairo areas though: * We track via gdk_window_mark_paint_from_clip() whenever gtk is painting over a region we previously rendered with opengl (flushed_region). This area (needs_blend_region) is blended rather than copied at the end of the frame. * If we're drawing a gl texture with alpha we first copy the current cairo_surface inside the target region to the back buffer before we blend over it. These two operations allow us full stacking of transparent gl and cairo regions.
2014-10-09 08:45:44 +00:00
switch (prop_id)
{
glcontext: Add GdkGLContext::allowed-apis This allows specifying the GL APIs in a more comprehensive way than gdk_gl_context_set_use_es().
2021-10-07 15:59:17 +00:00
case PROP_ALLOWED_APIS:
g_value_set_flags (value, priv->allowed_apis);
break;
glcontext: Add gdk_gl_context_get_api() This is mostly for inspector. Not sure if we also want to deprecate gdk_gl_context_get_use_es() in favor of this function.
2021-10-07 21:03:45 +00:00
case PROP_API:
g_value_set_flags (value, priv->api);
break;
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
case PROP_SHARED_CONTEXT:
gl: Deprecate gdk_gl_context_get_shared_context() It's not used anymore. And in particular we do want to keep the display context private, so we're not gonna return it from this function.
2021-07-10 01:24:00 +00:00
g_value_set_object (value, NULL);
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
break;
gdk: Add support for OpenGL This adds the new type GdkGLContext that wraps an OpenGL context for a particular native window. It also adds support for the gdk paint machinery to use OpenGL to draw everything. As soon as anyone creates a GL context for a native window we create a "paint context" for that GdkWindow and switch to using GL for painting it. This commit contains only an implementation for X11 (using GLX). The way painting works is that all client gl contexts draw into offscreen buffers rather than directly to the back buffer, and the way something gets onto the window is by using gdk_cairo_draw_from_gl() to draw part of that buffer onto the draw cairo context. As a fallback (if we're doing redirected drawing or some effect like a cairo_push_group()) we read back the gl buffer into memory and composite using cairo. This means that GL rendering works in all cases, including rendering to a PDF. However, this is not particularly fast. In the *typical* case, where we're drawing directly to the window in the regular paint loop we hit the fast path. The fast path uses opengl to draw the buffer to the window back buffer, either by blitting or texturing. Then we track the region that was drawn, and when the draw ends we paint the normal cairo surface to the window (using texture-from-pixmap in the X11 case, or texture from cairo image otherwise) in the regions where there is no gl painted. There are some complexities wrt layering of gl and cairo areas though: * We track via gdk_window_mark_paint_from_clip() whenever gtk is painting over a region we previously rendered with opengl (flushed_region). This area (needs_blend_region) is blended rather than copied at the end of the frame. * If we're drawing a gl texture with alpha we first copy the current cairo_surface inside the target region to the back buffer before we blend over it. These two operations allow us full stacking of transparent gl and cairo regions.
2014-10-09 08:45:44 +00:00
default:
glcontext: Add GdkGLContext::allowed-apis This allows specifying the GL APIs in a more comprehensive way than gdk_gl_context_set_use_es().
2021-10-07 15:59:17 +00:00
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
gdk: Add support for OpenGL This adds the new type GdkGLContext that wraps an OpenGL context for a particular native window. It also adds support for the gdk paint machinery to use OpenGL to draw everything. As soon as anyone creates a GL context for a native window we create a "paint context" for that GdkWindow and switch to using GL for painting it. This commit contains only an implementation for X11 (using GLX). The way painting works is that all client gl contexts draw into offscreen buffers rather than directly to the back buffer, and the way something gets onto the window is by using gdk_cairo_draw_from_gl() to draw part of that buffer onto the draw cairo context. As a fallback (if we're doing redirected drawing or some effect like a cairo_push_group()) we read back the gl buffer into memory and composite using cairo. This means that GL rendering works in all cases, including rendering to a PDF. However, this is not particularly fast. In the *typical* case, where we're drawing directly to the window in the regular paint loop we hit the fast path. The fast path uses opengl to draw the buffer to the window back buffer, either by blitting or texturing. Then we track the region that was drawn, and when the draw ends we paint the normal cairo surface to the window (using texture-from-pixmap in the X11 case, or texture from cairo image otherwise) in the regions where there is no gl painted. There are some complexities wrt layering of gl and cairo areas though: * We track via gdk_window_mark_paint_from_clip() whenever gtk is painting over a region we previously rendered with opengl (flushed_region). This area (needs_blend_region) is blended rather than copied at the end of the frame. * If we're drawing a gl texture with alpha we first copy the current cairo_surface inside the target region to the back buffer before we blend over it. These two operations allow us full stacking of transparent gl and cairo regions.
2014-10-09 08:45:44 +00:00
}
}
glcontext: Refactor realize function, fix interaction with shared context
2022-05-06 19:43:30 +00:00
#define N_EGL_ATTRS 16
#ifdef HAVE_EGL
static inline EGLenum
gdk_api_to_egl_api (GdkGLAPI api)
{
switch (api)
{
case GDK_GL_API_GLES:
return EGL_OPENGL_ES_API;
case GDK_GL_API_GL:
default:
return EGL_OPENGL_API;
}
}
egl: Unify contexts Unify the X11 and Wayland EGL contexts. This is a bit ugly to implement, because I don't want to create an interface and I can't make them inherit from the same object, because one needs to inherit from X11GLContext and the other from WaylandGLContext. So we have to put the code in GdkGLContext and make sure non-EGL contexts can't accidentally run it. This is rather easy because we can just check for priv->egl_context != NULL.
2021-10-05 22:34:10 +00:00
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
glcontext: Refactor realize function, fix interaction with shared context
2022-05-06 19:43:30 +00:00
gdk_gl_context_create_egl_context (GdkGLContext *context,
GdkGLAPI api,
gboolean legacy)
gl: Add a realize() fallback Calling gdk_gl_context_realize() should always result in a valid result, so we need to provide a default implementation, to avoid a call to a NULL function pointer.
2016-05-23 07:31:47 +00:00
{
egl: Unify contexts Unify the X11 and Wayland EGL contexts. This is a bit ugly to implement, because I don't want to create an interface and I can't make them inherit from the same object, because one needs to inherit from X11GLContext and the other from WaylandGLContext. So we have to put the code in GdkGLContext and make sure non-EGL contexts can't accidentally run it. This is rather easy because we can just check for priv->egl_context != NULL.
2021-10-05 22:34:10 +00:00
GdkGLContextPrivate *priv = gdk_gl_context_get_instance_private (context);
GdkDisplay *display = gdk_gl_context_get_display (context);
EGLDisplay egl_display = gdk_display_get_egl_display (display);
glcontext: Make the creation of EGL context more obvious By splitting it into its own function it becomes more that the EGL code is a shared implementation.
2022-05-06 14:40:13 +00:00
GdkGLContext *share = gdk_display_get_gl_context (display);
GdkGLContextPrivate *share_priv = gdk_gl_context_get_instance_private (share);
glcontext: Refactor realize function, fix interaction with shared context
2022-05-06 19:43:30 +00:00
EGLConfig egl_config;
glcontext: Make the creation of EGL context more obvious By splitting it into its own function it becomes more that the EGL code is a shared implementation.
2022-05-06 14:40:13 +00:00
EGLContext ctx;
glcontext: Refactor realize function, fix interaction with shared context
2022-05-06 19:43:30 +00:00
EGLint context_attribs[N_EGL_ATTRS], i = 0, flags = 0;
egl: Make sure highest possible GL version is created The EGL spec states: The context returned must be the specified version, or a later version which is backwards compatible with that version. Even if a later version is returned, the specified version must correspond to a defined version of the client API. GTK has so far been relying on EGL implementations returning a later version, because that is what Mesa does. But ANGLE does not do that and only provides the minimum version, which means Windows EGL has been forced to use a lower EGL version for no reason. So fix this and try versions in order from highest to lowest.
2023-04-25 18:08:33 +00:00
gsize major_idx, minor_idx;
glcontext: Refactor realize function, fix interaction with shared context
2022-05-06 19:43:30 +00:00
gboolean debug_bit, forward_bit;
glcontext: Compute matching version the simple way Do it all in one function instead of requiring two different ones.
2023-04-25 19:45:31 +00:00
GdkGLVersion version;
egl: Make sure highest possible GL version is created The EGL spec states: The context returned must be the specified version, or a later version which is backwards compatible with that version. Even if a later version is returned, the specified version must correspond to a defined version of the client API. GTK has so far been relying on EGL implementations returning a later version, because that is what Mesa does. But ANGLE does not do that and only provides the minimum version, which means Windows EGL has been forced to use a lower EGL version for no reason. So fix this and try versions in order from highest to lowest.
2023-04-25 18:08:33 +00:00
const GdkGLVersion* supported_versions;
gsize j;
glcontext: Make the creation of EGL context more obvious By splitting it into its own function it becomes more that the EGL code is a shared implementation.
2022-05-06 14:40:13 +00:00
G_GNUC_UNUSED gint64 start_time = GDK_PROFILER_CURRENT_TIME;
glcontext: Refactor realize function, fix interaction with shared context
2022-05-06 19:43:30 +00:00
if (!gdk_gl_context_is_api_allowed (context, api, NULL))
return 0;
/* We will use the default version matching the context status
* unless the user requested a version which makes sense */
glcontext: Compute matching version the simple way Do it all in one function instead of requiring two different ones.
2023-04-25 19:45:31 +00:00
gdk_gl_context_get_matching_version (context, api, legacy, &version);
glcontext: Refactor realize function, fix interaction with shared context
2022-05-06 19:43:30 +00:00
if (!eglBindAPI (gdk_api_to_egl_api (api)))
return 0;
gdkglcontext.c: Ensure EGL contexts are in-sync with shared context The EGL context that we are actually creating must have matching OpenGL/ES versions and allowed GL API set with the previously-created EGL context that will be shared with it so that they can interoperate together, if applicable. This will fix the situation by making sure that we request for the OpenGL/ES version and OpenGL API set that match with what we have in our shared EGL context. Otherwise, the newly-created EGL context assumed a OpenGL/ES 2.0 context that supported desktop OpenGL, which may not be what we wanted, such as in the case of libANGLE.
2022-01-17 09:27:10 +00:00
glcontext: Make the creation of EGL context more obvious By splitting it into its own function it becomes more that the EGL code is a shared implementation.
2022-05-06 14:40:13 +00:00
debug_bit = gdk_gl_context_get_debug_enabled (context);
forward_bit = gdk_gl_context_get_forward_compatible (context);
egl: Unify contexts Unify the X11 and Wayland EGL contexts. This is a bit ugly to implement, because I don't want to create an interface and I can't make them inherit from the same object, because one needs to inherit from X11GLContext and the other from WaylandGLContext. So we have to put the code in GdkGLContext and make sure non-EGL contexts can't accidentally run it. This is rather easy because we can just check for priv->egl_context != NULL.
2021-10-05 22:34:10 +00:00
glcontext: Make the creation of EGL context more obvious By splitting it into its own function it becomes more that the EGL code is a shared implementation.
2022-05-06 14:40:13 +00:00
if (display->have_egl_no_config_context)
egl_config = NULL;
else
egl_config = gdk_display_get_egl_config (display);
egl: Support EGL_KHR_no_config_context If the extension is supported, we create configless contexts. This will come in handy real soon now, we use different configs for HDR and SDR.
2021-10-06 00:41:31 +00:00
glcontext: Make the creation of EGL context more obvious By splitting it into its own function it becomes more that the EGL code is a shared implementation.
2022-05-06 14:40:13 +00:00
if (debug_bit)
flags |= EGL_CONTEXT_OPENGL_DEBUG_BIT_KHR;
if (forward_bit)
flags |= EGL_CONTEXT_OPENGL_FORWARD_COMPATIBLE_BIT_KHR;
egl: Unify contexts Unify the X11 and Wayland EGL contexts. This is a bit ugly to implement, because I don't want to create an interface and I can't make them inherit from the same object, because one needs to inherit from X11GLContext and the other from WaylandGLContext. So we have to put the code in GdkGLContext and make sure non-EGL contexts can't accidentally run it. This is rather easy because we can just check for priv->egl_context != NULL.
2021-10-05 22:34:10 +00:00
glcontext: Refactor realize function, fix interaction with shared context
2022-05-06 19:43:30 +00:00
if (api == GDK_GL_API_GL)
egl: Unify contexts Unify the X11 and Wayland EGL contexts. This is a bit ugly to implement, because I don't want to create an interface and I can't make them inherit from the same object, because one needs to inherit from X11GLContext and the other from WaylandGLContext. So we have to put the code in GdkGLContext and make sure non-EGL contexts can't accidentally run it. This is rather easy because we can just check for priv->egl_context != NULL.
2021-10-05 22:34:10 +00:00
{
glcontext: Make the creation of EGL context more obvious By splitting it into its own function it becomes more that the EGL code is a shared implementation.
2022-05-06 14:40:13 +00:00
/* We want a core profile, unless in legacy mode */
glcontext: Refactor realize function, fix interaction with shared context
2022-05-06 19:43:30 +00:00
context_attribs[i++] = EGL_CONTEXT_OPENGL_PROFILE_MASK;
context_attribs[i++] = legacy
? EGL_CONTEXT_OPENGL_COMPATIBILITY_PROFILE_BIT
: EGL_CONTEXT_OPENGL_CORE_PROFILE_BIT;
glcontext: Make the creation of EGL context more obvious By splitting it into its own function it becomes more that the EGL code is a shared implementation.
2022-05-06 14:40:13 +00:00
}
gdkglcontext.c: Ensure EGL contexts are in-sync with shared context The EGL context that we are actually creating must have matching OpenGL/ES versions and allowed GL API set with the previously-created EGL context that will be shared with it so that they can interoperate together, if applicable. This will fix the situation by making sure that we request for the OpenGL/ES version and OpenGL API set that match with what we have in our shared EGL context. Otherwise, the newly-created EGL context assumed a OpenGL/ES 2.0 context that supported desktop OpenGL, which may not be what we wanted, such as in the case of libANGLE.
2022-01-17 09:27:10 +00:00
glcontext: Refactor realize function, fix interaction with shared context
2022-05-06 19:43:30 +00:00
if (legacy || api == GDK_GL_API_GLES)
flags &= ~EGL_CONTEXT_OPENGL_FORWARD_COMPATIBLE_BIT_KHR;
egl: Unify contexts Unify the X11 and Wayland EGL contexts. This is a bit ugly to implement, because I don't want to create an interface and I can't make them inherit from the same object, because one needs to inherit from X11GLContext and the other from WaylandGLContext. So we have to put the code in GdkGLContext and make sure non-EGL contexts can't accidentally run it. This is rather easy because we can just check for priv->egl_context != NULL.
2021-10-05 22:34:10 +00:00
glcontext: Refactor realize function, fix interaction with shared context
2022-05-06 19:43:30 +00:00
context_attribs[i++] = EGL_CONTEXT_MAJOR_VERSION;
egl: Make sure highest possible GL version is created The EGL spec states: The context returned must be the specified version, or a later version which is backwards compatible with that version. Even if a later version is returned, the specified version must correspond to a defined version of the client API. GTK has so far been relying on EGL implementations returning a later version, because that is what Mesa does. But ANGLE does not do that and only provides the minimum version, which means Windows EGL has been forced to use a lower EGL version for no reason. So fix this and try versions in order from highest to lowest.
2023-04-25 18:08:33 +00:00
major_idx = i++;
glcontext: Refactor realize function, fix interaction with shared context
2022-05-06 19:43:30 +00:00
context_attribs[i++] = EGL_CONTEXT_MINOR_VERSION;
egl: Make sure highest possible GL version is created The EGL spec states: The context returned must be the specified version, or a later version which is backwards compatible with that version. Even if a later version is returned, the specified version must correspond to a defined version of the client API. GTK has so far been relying on EGL implementations returning a later version, because that is what Mesa does. But ANGLE does not do that and only provides the minimum version, which means Windows EGL has been forced to use a lower EGL version for no reason. So fix this and try versions in order from highest to lowest.
2023-04-25 18:08:33 +00:00
minor_idx = i++;
glcontext: Make the creation of EGL context more obvious By splitting it into its own function it becomes more that the EGL code is a shared implementation.
2022-05-06 14:40:13 +00:00
context_attribs[i++] = EGL_CONTEXT_FLAGS_KHR;
context_attribs[i++] = flags;
egl: Support EGL_KHR_no_config_context If the extension is supported, we create configless contexts. This will come in handy real soon now, we use different configs for HDR and SDR.
2021-10-06 00:41:31 +00:00
glcontext: Make the creation of EGL context more obvious By splitting it into its own function it becomes more that the EGL code is a shared implementation.
2022-05-06 14:40:13 +00:00
context_attribs[i++] = EGL_NONE;
g_assert (i < N_EGL_ATTRS);
egl: Unify contexts Unify the X11 and Wayland EGL contexts. This is a bit ugly to implement, because I don't want to create an interface and I can't make them inherit from the same object, because one needs to inherit from X11GLContext and the other from WaylandGLContext. So we have to put the code in GdkGLContext and make sure non-EGL contexts can't accidentally run it. This is rather easy because we can just check for priv->egl_context != NULL.
2021-10-05 22:34:10 +00:00
gdk: Use the new debug macros
2022-09-23 00:48:58 +00:00
GDK_DISPLAY_DEBUG (display, OPENGL,
"Creating EGL context version %d.%d (debug:%s, forward:%s, legacy:%s, es:%s)",
gdk: Introduce GdkGLVersion ... and use it. Makes the code simpler.
2023-04-25 17:17:07 +00:00
gdk_gl_version_get_major (&version), gdk_gl_version_get_minor (&version),
gdk: Use the new debug macros
2022-09-23 00:48:58 +00:00
debug_bit ? "yes" : "no",
forward_bit ? "yes" : "no",
legacy ? "yes" : "no",
api == GDK_GL_API_GLES ? "yes" : "no");
egl: Unify contexts Unify the X11 and Wayland EGL contexts. This is a bit ugly to implement, because I don't want to create an interface and I can't make them inherit from the same object, because one needs to inherit from X11GLContext and the other from WaylandGLContext. So we have to put the code in GdkGLContext and make sure non-EGL contexts can't accidentally run it. This is rather easy because we can just check for priv->egl_context != NULL.
2021-10-05 22:34:10 +00:00
egl: Make sure highest possible GL version is created The EGL spec states: The context returned must be the specified version, or a later version which is backwards compatible with that version. Even if a later version is returned, the specified version must correspond to a defined version of the client API. GTK has so far been relying on EGL implementations returning a later version, because that is what Mesa does. But ANGLE does not do that and only provides the minimum version, which means Windows EGL has been forced to use a lower EGL version for no reason. So fix this and try versions in order from highest to lowest.
2023-04-25 18:08:33 +00:00
supported_versions = gdk_gl_versions_get_for_api (api);
Address various static analysis complaints These were picked out of the scan_build logs in ci.
2023-11-22 05:06:24 +00:00
ctx = EGL_NO_CONTEXT;
egl: Make sure highest possible GL version is created The EGL spec states: The context returned must be the specified version, or a later version which is backwards compatible with that version. Even if a later version is returned, the specified version must correspond to a defined version of the client API. GTK has so far been relying on EGL implementations returning a later version, because that is what Mesa does. But ANGLE does not do that and only provides the minimum version, which means Windows EGL has been forced to use a lower EGL version for no reason. So fix this and try versions in order from highest to lowest.
2023-04-25 18:08:33 +00:00
for (j = 0; gdk_gl_version_greater_equal (&supported_versions[j], &version); j++)
{
context_attribs [major_idx] = gdk_gl_version_get_major (&supported_versions[j]);
context_attribs [minor_idx] = gdk_gl_version_get_minor (&supported_versions[j]);
ctx = eglCreateContext (egl_display,
egl_config,
share ? share_priv->egl_context : EGL_NO_CONTEXT,
context_attribs);
Address various static analysis complaints These were picked out of the scan_build logs in ci.
2023-11-22 05:06:24 +00:00
if (ctx != EGL_NO_CONTEXT)
egl: Make sure highest possible GL version is created The EGL spec states: The context returned must be the specified version, or a later version which is backwards compatible with that version. Even if a later version is returned, the specified version must correspond to a defined version of the client API. GTK has so far been relying on EGL implementations returning a later version, because that is what Mesa does. But ANGLE does not do that and only provides the minimum version, which means Windows EGL has been forced to use a lower EGL version for no reason. So fix this and try versions in order from highest to lowest.
2023-04-25 18:08:33 +00:00
break;
}
egl: Unify contexts Unify the X11 and Wayland EGL contexts. This is a bit ugly to implement, because I don't want to create an interface and I can't make them inherit from the same object, because one needs to inherit from X11GLContext and the other from WaylandGLContext. So we have to put the code in GdkGLContext and make sure non-EGL contexts can't accidentally run it. This is rather easy because we can just check for priv->egl_context != NULL.
2021-10-05 22:34:10 +00:00
Address various static analysis complaints These were picked out of the scan_build logs in ci.
2023-11-22 05:06:24 +00:00
if (ctx == EGL_NO_CONTEXT)
egl: Make sure highest possible GL version is created The EGL spec states: The context returned must be the specified version, or a later version which is backwards compatible with that version. Even if a later version is returned, the specified version must correspond to a defined version of the client API. GTK has so far been relying on EGL implementations returning a later version, because that is what Mesa does. But ANGLE does not do that and only provides the minimum version, which means Windows EGL has been forced to use a lower EGL version for no reason. So fix this and try versions in order from highest to lowest.
2023-04-25 18:08:33 +00:00
return 0;
egl: Unify contexts Unify the X11 and Wayland EGL contexts. This is a bit ugly to implement, because I don't want to create an interface and I can't make them inherit from the same object, because one needs to inherit from X11GLContext and the other from WaylandGLContext. So we have to put the code in GdkGLContext and make sure non-EGL contexts can't accidentally run it. This is rather easy because we can just check for priv->egl_context != NULL.
2021-10-05 22:34:10 +00:00
gdk: Use the new debug macros
2022-09-23 00:48:58 +00:00
GDK_DISPLAY_DEBUG (display, OPENGL, "Created EGL context[%p]", ctx);
egl: Unify contexts Unify the X11 and Wayland EGL contexts. This is a bit ugly to implement, because I don't want to create an interface and I can't make them inherit from the same object, because one needs to inherit from X11GLContext and the other from WaylandGLContext. So we have to put the code in GdkGLContext and make sure non-EGL contexts can't accidentally run it. This is rather easy because we can just check for priv->egl_context != NULL.
2021-10-05 22:34:10 +00:00
glcontext: Make the creation of EGL context more obvious By splitting it into its own function it becomes more that the EGL code is a shared implementation.
2022-05-06 14:40:13 +00:00
priv->egl_context = ctx;
egl: Make sure highest possible GL version is created The EGL spec states: The context returned must be the specified version, or a later version which is backwards compatible with that version. Even if a later version is returned, the specified version must correspond to a defined version of the client API. GTK has so far been relying on EGL implementations returning a later version, because that is what Mesa does. But ANGLE does not do that and only provides the minimum version, which means Windows EGL has been forced to use a lower EGL version for no reason. So fix this and try versions in order from highest to lowest.
2023-04-25 18:08:33 +00:00
gdk_gl_context_set_version (context, &supported_versions[j]);
glcontext: Refactor realize function, fix interaction with shared context
2022-05-06 19:43:30 +00:00
gdk_gl_context_set_is_legacy (context, legacy);
egl: Unify contexts Unify the X11 and Wayland EGL contexts. This is a bit ugly to implement, because I don't want to create an interface and I can't make them inherit from the same object, because one needs to inherit from X11GLContext and the other from WaylandGLContext. So we have to put the code in GdkGLContext and make sure non-EGL contexts can't accidentally run it. This is rather easy because we can just check for priv->egl_context != NULL.
2021-10-05 22:34:10 +00:00
glcontext: Make the creation of EGL context more obvious By splitting it into its own function it becomes more that the EGL code is a shared implementation.
2022-05-06 14:40:13 +00:00
if (epoxy_has_egl_extension (egl_display, "EGL_KHR_swap_buffers_with_damage"))
glcontext: Refactor realize function, fix interaction with shared context
2022-05-06 19:43:30 +00:00
priv->eglSwapBuffersWithDamage = (gpointer) epoxy_eglGetProcAddress ("eglSwapBuffersWithDamageKHR");
glcontext: Make the creation of EGL context more obvious By splitting it into its own function it becomes more that the EGL code is a shared implementation.
2022-05-06 14:40:13 +00:00
else if (epoxy_has_egl_extension (egl_display, "EGL_EXT_swap_buffers_with_damage"))
glcontext: Refactor realize function, fix interaction with shared context
2022-05-06 19:43:30 +00:00
priv->eglSwapBuffersWithDamage = (gpointer) epoxy_eglGetProcAddress ("eglSwapBuffersWithDamageEXT");
egl: Unify contexts Unify the X11 and Wayland EGL contexts. This is a bit ugly to implement, because I don't want to create an interface and I can't make them inherit from the same object, because one needs to inherit from X11GLContext and the other from WaylandGLContext. So we have to put the code in GdkGLContext and make sure non-EGL contexts can't accidentally run it. This is rather easy because we can just check for priv->egl_context != NULL.
2021-10-05 22:34:10 +00:00
Tweak profiling strings Capitalize our mark names, and use GTK as category. The justification is: it looks better in sysprof.
2024-01-21 18:58:09 +00:00
gdk_profiler_end_mark (start_time, "Create EGL context", NULL);
egl: Unify contexts Unify the X11 and Wayland EGL contexts. This is a bit ugly to implement, because I don't want to create an interface and I can't make them inherit from the same object, because one needs to inherit from X11GLContext and the other from WaylandGLContext. So we have to put the code in GdkGLContext and make sure non-EGL contexts can't accidentally run it. This is rather easy because we can just check for priv->egl_context != NULL.
2021-10-05 22:34:10 +00:00
glcontext: Make the creation of EGL context more obvious By splitting it into its own function it becomes more that the EGL code is a shared implementation.
2022-05-06 14:40:13 +00:00
return api;
}
egl: Unify contexts Unify the X11 and Wayland EGL contexts. This is a bit ugly to implement, because I don't want to create an interface and I can't make them inherit from the same object, because one needs to inherit from X11GLContext and the other from WaylandGLContext. So we have to put the code in GdkGLContext and make sure non-EGL contexts can't accidentally run it. This is rather easy because we can just check for priv->egl_context != NULL.
2021-10-05 22:34:10 +00:00
glcontext: Refactor realize function, fix interaction with shared context
2022-05-06 19:43:30 +00:00
static GdkGLAPI
gdk_gl_context_realize_egl (GdkGLContext *context,
GError **error)
{
GdkDisplay *display = gdk_gl_context_get_display (context);
GdkGLContext *share = gdk_display_get_gl_context (display);
Use GLES by default With the advent of dmabuf support, using GLES has become more attractive, since we can use its external texture support to support more dmabuf formats. You can go back to the previous preference order by setting GDK_DEBUG=gl-prefer-gl
2023-11-18 08:20:59 +00:00
GdkDebugFlags flags;
glcontext: Refactor realize function, fix interaction with shared context
2022-05-06 19:43:30 +00:00
GdkGLAPI api, preferred_api;
gboolean prefer_legacy;
Use GLES by default With the advent of dmabuf support, using GLES has become more attractive, since we can use its external texture support to support more dmabuf formats. You can go back to the previous preference order by setting GDK_DEBUG=gl-prefer-gl
2023-11-18 08:20:59 +00:00
flags = gdk_display_get_debug_flags(display);
glcontext: Refactor realize function, fix interaction with shared context
2022-05-06 19:43:30 +00:00
if (share && gdk_gl_context_is_api_allowed (context,
gdk_gl_context_get_api (share),
NULL))
preferred_api = gdk_gl_context_get_api (share);
Use GLES by default With the advent of dmabuf support, using GLES has become more attractive, since we can use its external texture support to support more dmabuf formats. You can go back to the previous preference order by setting GDK_DEBUG=gl-prefer-gl
2023-11-18 08:20:59 +00:00
else if ((flags & GDK_DEBUG_GL_PREFER_GL) != 0 &&
gdk_gl_context_is_api_allowed (context, GDK_GL_API_GL, NULL))
glcontext: Refactor realize function, fix interaction with shared context
2022-05-06 19:43:30 +00:00
preferred_api = GDK_GL_API_GL;
else if (gdk_gl_context_is_api_allowed (context, GDK_GL_API_GLES, NULL))
preferred_api = GDK_GL_API_GLES;
Use GLES by default With the advent of dmabuf support, using GLES has become more attractive, since we can use its external texture support to support more dmabuf formats. You can go back to the previous preference order by setting GDK_DEBUG=gl-prefer-gl
2023-11-18 08:20:59 +00:00
else if ((flags & GDK_DEBUG_GL_PREFER_GL) == 0 &&
gdk_gl_context_is_api_allowed (context, GDK_GL_API_GL, NULL))
preferred_api = GDK_GL_API_GL;
glcontext: Refactor realize function, fix interaction with shared context
2022-05-06 19:43:30 +00:00
else
{
g_set_error_literal (error, GDK_GL_ERROR,
GDK_GL_ERROR_NOT_AVAILABLE,
_("No GL API allowed."));
return 0;
}
gdk: use EGL_KHR_swap_buffers_with_damage It appears that NVIDIA does not implement EGL_EXT_swap_buffers_with_damage on their EGL implementation, but does implement the KHR variant of it. This checks for a suitable implementation and stores a pointer to the compatible implementation within the GdkGLContextPrivate struct.
2022-03-03 06:59:23 +00:00
Drop the gl-legacy debug value The consensus is that we can do without this.
2023-11-18 23:58:37 +00:00
prefer_legacy = share != NULL && gdk_gl_context_is_legacy (share);
egl: Unify contexts Unify the X11 and Wayland EGL contexts. This is a bit ugly to implement, because I don't want to create an interface and I can't make them inherit from the same object, because one needs to inherit from X11GLContext and the other from WaylandGLContext. So we have to put the code in GdkGLContext and make sure non-EGL contexts can't accidentally run it. This is rather easy because we can just check for priv->egl_context != NULL.
2021-10-05 22:34:10 +00:00
glcontext: Refactor realize function, fix interaction with shared context
2022-05-06 19:43:30 +00:00
if (preferred_api == GDK_GL_API_GL)
{
if ((api = gdk_gl_context_create_egl_context (context, GDK_GL_API_GL, prefer_legacy)) ||
(api = gdk_gl_context_create_egl_context (context, GDK_GL_API_GLES, FALSE)) ||
(api = gdk_gl_context_create_egl_context (context, GDK_GL_API_GL, TRUE)))
return api;
egl: Unify contexts Unify the X11 and Wayland EGL contexts. This is a bit ugly to implement, because I don't want to create an interface and I can't make them inherit from the same object, because one needs to inherit from X11GLContext and the other from WaylandGLContext. So we have to put the code in GdkGLContext and make sure non-EGL contexts can't accidentally run it. This is rather easy because we can just check for priv->egl_context != NULL.
2021-10-05 22:34:10 +00:00
}
glcontext: Refactor realize function, fix interaction with shared context
2022-05-06 19:43:30 +00:00
else
{
if ((api = gdk_gl_context_create_egl_context (context, GDK_GL_API_GLES, FALSE)) ||
(api = gdk_gl_context_create_egl_context (context, GDK_GL_API_GL, prefer_legacy)) ||
(api = gdk_gl_context_create_egl_context (context, GDK_GL_API_GL, TRUE)))
return api;
}
g_set_error_literal (error, GDK_GL_ERROR,
GDK_GL_ERROR_NOT_AVAILABLE,
_("Unable to create a GL context"));
return 0;
}
#endif /* HAVE_EGL */
glcontext: Make the creation of EGL context more obvious By splitting it into its own function it becomes more that the EGL code is a shared implementation.
2022-05-06 14:40:13 +00:00
static GdkGLAPI
gdk_gl_context_default_realize (GdkGLContext *context,
GError **error)
{
#ifdef HAVE_EGL
GdkDisplay *display = gdk_gl_context_get_display (context);
egl: Unify contexts Unify the X11 and Wayland EGL contexts. This is a bit ugly to implement, because I don't want to create an interface and I can't make them inherit from the same object, because one needs to inherit from X11GLContext and the other from WaylandGLContext. So we have to put the code in GdkGLContext and make sure non-EGL contexts can't accidentally run it. This is rather easy because we can just check for priv->egl_context != NULL.
2021-10-05 22:34:10 +00:00
glcontext: Make the creation of EGL context more obvious By splitting it into its own function it becomes more that the EGL code is a shared implementation.
2022-05-06 14:40:13 +00:00
if (gdk_display_get_egl_display (display))
return gdk_gl_context_realize_egl (context, error);
egl: Unify contexts Unify the X11 and Wayland EGL contexts. This is a bit ugly to implement, because I don't want to create an interface and I can't make them inherit from the same object, because one needs to inherit from X11GLContext and the other from WaylandGLContext. So we have to put the code in GdkGLContext and make sure non-EGL contexts can't accidentally run it. This is rather easy because we can just check for priv->egl_context != NULL.
2021-10-05 22:34:10 +00:00
#endif
gl: Add a realize() fallback Calling gdk_gl_context_realize() should always result in a valid result, so we need to provide a default implementation, to avoid a call to a NULL function pointer.
2016-05-23 07:31:47 +00:00
g_set_error_literal (error, GDK_GL_ERROR, GDK_GL_ERROR_NOT_AVAILABLE,
glcontext: Handle failure of eglBindAPI() We don't want to be sure if we have GL or GLES.
2021-10-06 00:36:59 +00:00
_("The current backend does not support 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
return 0;
gl: Add a realize() fallback Calling gdk_gl_context_realize() should always result in a valid result, so we need to provide a default implementation, to avoid a call to a NULL function pointer.
2016-05-23 07:31:47 +00:00
}
egl: Unify contexts Unify the X11 and Wayland EGL contexts. This is a bit ugly to implement, because I don't want to create an interface and I can't make them inherit from the same object, because one needs to inherit from X11GLContext and the other from WaylandGLContext. So we have to put the code in GdkGLContext and make sure non-EGL contexts can't accidentally run it. This is rather easy because we can just check for priv->egl_context != NULL.
2021-10-05 22:34:10 +00:00
#undef N_EGL_ATTRS
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_gl_context_real_get_damage (GdkGLContext *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_draw_context_get_surface (GDK_DRAW_CONTEXT (context));
egl: Unify contexts Unify the X11 and Wayland EGL contexts. This is a bit ugly to implement, because I don't want to create an interface and I can't make them inherit from the same object, because one needs to inherit from X11GLContext and the other from WaylandGLContext. So we have to put the code in GdkGLContext and make sure non-EGL contexts can't accidentally run it. This is rather easy because we can just check for priv->egl_context != NULL.
2021-10-05 22:34:10 +00:00
#ifdef HAVE_EGL
GdkGLContextPrivate *priv = gdk_gl_context_get_instance_private (context);
GdkDisplay *display = gdk_draw_context_get_display (GDK_DRAW_CONTEXT (context));
if (priv->egl_context && display->have_egl_buffer_age)
{
EGLSurface egl_surface;
int buffer_age = 0;
egl_surface = gdk_surface_get_egl_surface (surface);
gdk_gl_context_make_current (context);
eglQuerySurface (gdk_display_get_egl_display (display), egl_surface,
EGL_BUFFER_AGE_EXT, &buffer_age);
gl: Rewrite update area tracking code Make it more generic. That way we could dynamically change the number of buffers we track. We don't do that yet though.
2023-05-24 19:40:20 +00:00
if (buffer_age > 0 && buffer_age <= GDK_GL_MAX_TRACKED_BUFFERS)
egl: Unify contexts Unify the X11 and Wayland EGL contexts. This is a bit ugly to implement, because I don't want to create an interface and I can't make them inherit from the same object, because one needs to inherit from X11GLContext and the other from WaylandGLContext. So we have to put the code in GdkGLContext and make sure non-EGL contexts can't accidentally run it. This is rather easy because we can just check for priv->egl_context != NULL.
2021-10-05 22:34:10 +00:00
{
gl: Rewrite update area tracking code Make it more generic. That way we could dynamically change the number of buffers we track. We don't do that yet though.
2023-05-24 19:40:20 +00:00
cairo_region_t *damage = cairo_region_create ();
int i;
for (i = 0; i < buffer_age - 1; i++)
{
if (context->old_updated_area[i] == NULL)
{
cairo_region_create_rectangle (&(GdkRectangle) {
0, 0,
gdk_surface_get_width (surface),
gdk_surface_get_height (surface)
});
break;
}
cairo_region_union (damage, context->old_updated_area[i]);
}
return damage;
egl: Unify contexts Unify the X11 and Wayland EGL contexts. This is a bit ugly to implement, because I don't want to create an interface and I can't make them inherit from the same object, because one needs to inherit from X11GLContext and the other from WaylandGLContext. So we have to put the code in GdkGLContext and make sure non-EGL contexts can't accidentally run it. This is rather easy because we can just check for priv->egl_context != NULL.
2021-10-05 22:34:10 +00:00
}
}
#endif
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 cairo_region_create_rectangle (&(GdkRectangle) {
0, 0,
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_surface_get_width (surface),
gdk_surface_get_height (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
});
}
gdk: Add gdk_gl_context_is_shared() ... and use it in the GL renderers.
2021-06-30 02:52:35 +00:00
static gboolean
gdk_gl_context_real_is_shared (GdkGLContext *self,
GdkGLContext *other)
{
if (gdk_draw_context_get_display (GDK_DRAW_CONTEXT (self)) != gdk_draw_context_get_display (GDK_DRAW_CONTEXT (other)))
return FALSE;
/* XXX: Should we check es or legacy here? */
return TRUE;
}
gdk: Add private GLContext::is_current() check ... and use this check in gdk_gl_context_make_current() and gdk_gl_context_get_current() to make sure the context really is still current. The context no longer being current can happen when external GL implementations make their own contexts current in the same threads GDK contexts are used in. And that can happen for example by WebKit. Theoretically, this should also allow external EGL code to run in X11 applications when GDK chooses to use GLX, but I didn't try it. Fixes #5392
2023-02-02 01:49:56 +00:00
static gboolean
gdk_gl_context_real_is_current (GdkGLContext *self)
{
#ifdef HAVE_EGL
GdkGLContextPrivate *priv = gdk_gl_context_get_instance_private (self);
return priv->egl_context == eglGetCurrentContext ();
#else
return TRUE;
#endif
}
egl: Unify contexts Unify the X11 and Wayland EGL contexts. This is a bit ugly to implement, because I don't want to create an interface and I can't make them inherit from the same object, because one needs to inherit from X11GLContext and the other from WaylandGLContext. So we have to put the code in GdkGLContext and make sure non-EGL contexts can't accidentally run it. This is rather easy because we can just check for priv->egl_context != NULL.
2021-10-05 22:34:10 +00:00
static gboolean
gdk_gl_context_real_clear_current (GdkGLContext *context)
{
#ifdef HAVE_EGL
glcontext: Avoid gcc warning on non-egl build
2021-11-03 22:40:33 +00:00
GdkDisplay *display = gdk_gl_context_get_display (context);
egl: Unify contexts Unify the X11 and Wayland EGL contexts. This is a bit ugly to implement, because I don't want to create an interface and I can't make them inherit from the same object, because one needs to inherit from X11GLContext and the other from WaylandGLContext. So we have to put the code in GdkGLContext and make sure non-EGL contexts can't accidentally run it. This is rather easy because we can just check for priv->egl_context != NULL.
2021-10-05 22:34:10 +00:00
GdkGLContextPrivate *priv = gdk_gl_context_get_instance_private (context);
if (priv->egl_context == NULL)
return FALSE;
return eglMakeCurrent (gdk_display_get_egl_display (display),
EGL_NO_SURFACE,
EGL_NO_SURFACE,
EGL_NO_CONTEXT);
#else
return FALSE;
#endif
}
static gboolean
gdk_gl_context_real_make_current (GdkGLContext *context,
gboolean surfaceless)
{
#ifdef HAVE_EGL
GdkGLContextPrivate *priv = gdk_gl_context_get_instance_private (context);
GdkDisplay *display = gdk_gl_context_get_display (context);
EGLSurface egl_surface;
if (priv->egl_context == NULL)
return FALSE;
if (!surfaceless)
egl_surface = gdk_surface_get_egl_surface (gdk_gl_context_get_surface (context));
else
egl_surface = EGL_NO_SURFACE;
return eglMakeCurrent (gdk_display_get_egl_display (display),
egl_surface,
egl_surface,
priv->egl_context);
#else
return FALSE;
#endif
}
Make fractional scaling for GL opt-in Fractional scaling with the GL renderer is experimental for now, so we disable it unless GDK_DEBUG=gl-fractional is set. This will give us time to work out the kinks.
2023-04-02 14:24:37 +00:00
double
gdk_gl_context_get_scale (GdkGLContext *self)
{
GdkDisplay *display;
GdkSurface *surface;
double scale;
surface = gdk_draw_context_get_surface (GDK_DRAW_CONTEXT (self));
scale = gdk_surface_get_scale (surface);
display = gdk_gl_context_get_display (self);
gdk: Enable fractional scaling for GL by default The ngl renderer has good support for fractional scaling, so we can enable this by default now. If you are using the gl renderer, you can disable fractional scaling with the GDK_DEBUG=gl-no-fractional environment variable.
2024-01-25 15:59:14 +00:00
if (gdk_display_get_debug_flags (display) & GDK_DEBUG_GL_NO_FRACTIONAL)
Make fractional scaling for GL opt-in Fractional scaling with the GL renderer is experimental for now, so we disable it unless GDK_DEBUG=gl-fractional is set. This will give us time to work out the kinks.
2023-04-02 14:24:37 +00:00
scale = ceil (scale);
return scale;
}
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_gl_context_real_begin_frame (GdkDrawContext *draw_context,
gdk: Replace prefers_high_depth with depth Now that we track depth, we can also pass it into the GDK frame code. For now it's just passed along, code acts the same as with prefers_high_depth.
2023-06-16 06:00:19 +00:00
GdkMemoryDepth depth,
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
cairo_region_t *region)
{
GdkGLContext *context = GDK_GL_CONTEXT (draw_context);
egl: Implement HDR support If EGL supports: * no-config contexts * >8bits pixel formats * (optionally) floating point pixel formats Then select such a profile as the HDR format and use it when HDR is requested.
2021-10-06 01:33:24 +00:00
G_GNUC_UNUSED GdkGLContextPrivate *priv = gdk_gl_context_get_instance_private (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;
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
cairo_region_t *damage;
Make fractional scaling for GL opt-in Fractional scaling with the GL renderer is experimental for now, so we disable it unless GDK_DEBUG=gl-fractional is set. This will give us time to work out the kinks.
2023-04-02 14:24:37 +00:00
double scale;
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
int ww, wh;
gl: Rewrite update area tracking code Make it more generic. That way we could dynamically change the number of buffers we track. We don't do that yet though.
2023-05-24 19:40:20 +00:00
int i;
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
egl: Implement HDR support If EGL supports: * no-config contexts * >8bits pixel formats * (optionally) floating point pixel formats Then select such a profile as the HDR format and use it when HDR is requested.
2021-10-06 01:33:24 +00:00
surface = gdk_draw_context_get_surface (draw_context);
Make fractional scaling for GL opt-in Fractional scaling with the GL renderer is experimental for now, so we disable it unless GDK_DEBUG=gl-fractional is set. This will give us time to work out the kinks.
2023-04-02 14:24:37 +00:00
scale = gdk_gl_context_get_scale (context);
egl: Implement HDR support If EGL supports: * no-config contexts * >8bits pixel formats * (optionally) floating point pixel formats Then select such a profile as the HDR format and use it when HDR is requested.
2021-10-06 01:33:24 +00:00
#ifdef HAVE_EGL
if (priv->egl_context)
gdk: Replace prefers_high_depth with depth Now that we track depth, we can also pass it into the GDK frame code. For now it's just passed along, code acts the same as with prefers_high_depth.
2023-06-16 06:00:19 +00:00
gdk_surface_ensure_egl_surface (surface, depth != GDK_MEMORY_U8);
egl: Implement HDR support If EGL supports: * no-config contexts * >8bits pixel formats * (optionally) floating point pixel formats Then select such a profile as the HDR format and use it when HDR is requested.
2021-10-06 01:33:24 +00:00
#endif
gdk: Remove gdk_gl_context_get_damage() Remove it only form public API, because we still use the vfunc to figure out the damage area in begin_frame().
2018-04-20 15:04:36 +00:00
damage = GDK_GL_CONTEXT_GET_CLASS (context)->get_damage (context);
glcontext: Store the updated area in the right place We need to store the region *before* adding our own damage area, because we want to only store the changes of this frame, not the whole history. So do it in the same place Vulkan does it. Fixes #1900
2019-05-18 14:54:27 +00:00
gl: Rewrite update area tracking code Make it more generic. That way we could dynamically change the number of buffers we track. We don't do that yet though.
2023-05-24 19:40:20 +00:00
g_clear_pointer (&context->old_updated_area[GDK_GL_MAX_TRACKED_BUFFERS - 1], cairo_region_destroy);
for (i = GDK_GL_MAX_TRACKED_BUFFERS - 1; i > 0; i--)
{
context->old_updated_area[i] = context->old_updated_area[i - 1];
}
glcontext: Store the updated area in the right place We need to store the region *before* adding our own damage area, because we want to only store the changes of this frame, not the whole history. So do it in the same place Vulkan does it. Fixes #1900
2019-05-18 14:54:27 +00:00
context->old_updated_area[0] = cairo_region_copy (region);
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
cairo_region_union (region, damage);
cairo_region_destroy (damage);
Make fractional scaling for GL opt-in Fractional scaling with the GL renderer is experimental for now, so we disable it unless GDK_DEBUG=gl-fractional is set. This will give us time to work out the kinks.
2023-04-02 14:24:37 +00:00
ww = (int) ceil (gdk_surface_get_width (surface) * scale);
wh = (int) ceil (gdk_surface_get_height (surface) * scale);
gdk: Make gdk_window_begin_draw_frame() take a draw context ... instead of a gl context. This requires some refactoring in the way we mark the shared context as drawing: We now call begin_frame/end_frame() on it and ignore the call on the main context. Unfortunately we need to do this check in all vfuncs, which sucks. But I haven't found a better way.
2016-12-01 00:38:20 +00:00
gdk_gl_context_make_current (context);
/* Initial setup */
glClearColor (0.0f, 0.0f, 0.0f, 0.0f);
glDisable (GL_DEPTH_TEST);
glDisable (GL_BLEND);
glBlendFunc (GL_ONE, GL_ONE_MINUS_SRC_ALPHA);
glViewport (0, 0, ww, wh);
egl: Set the draw buffer to GL_BACK_LEFT Instead of using GL_BACK, use GL_BACK_LEFT, because the spec demands this (many drivers don't). Also move the call from the GDK backends into the GLContext code, as this is a generic EGL issue (nvidia being the main driver in need of this call, see 9c4c4eaaa121d784f591a591b95264647eaece96 for a longer discussion). Fixes #4402
2021-11-03 18:49:57 +00:00
#ifdef HAVE_EGL
glcontext: Use GdkGLVersion elsewhere ... and add a convenience API to generate GL versions from strings to make the gdk_gl_context_check() API nicer.
2023-04-25 17:32:12 +00:00
if (priv->egl_context && gdk_gl_context_check_version (context, NULL, "3.0"))
gles: GLES 2 doesn't have glDrawBuffers() So don't call it.
2021-12-25 13:43:33 +00:00
glDrawBuffers (1, (GLenum[1]) { gdk_gl_context_get_use_es (context) ? GL_BACK : GL_BACK_LEFT });
egl: Set the draw buffer to GL_BACK_LEFT Instead of using GL_BACK, use GL_BACK_LEFT, because the spec demands this (many drivers don't). Also move the call from the GDK backends into the GLContext code, as this is a generic EGL issue (nvidia being the main driver in need of this call, see 9c4c4eaaa121d784f591a591b95264647eaece96 for a longer discussion). Fixes #4402
2021-11-03 18:49:57 +00:00
#endif
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_gl_context_real_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)
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
{
egl: Unify contexts Unify the X11 and Wayland EGL contexts. This is a bit ugly to implement, because I don't want to create an interface and I can't make them inherit from the same object, because one needs to inherit from X11GLContext and the other from WaylandGLContext. So we have to put the code in GdkGLContext and make sure non-EGL contexts can't accidentally run it. This is rather easy because we can just check for priv->egl_context != NULL.
2021-10-05 22:34:10 +00:00
#ifdef HAVE_EGL
GdkGLContext *context = GDK_GL_CONTEXT (draw_context);
GdkGLContextPrivate *priv = gdk_gl_context_get_instance_private (context);
GdkSurface *surface = gdk_gl_context_get_surface (context);
GdkDisplay *display = gdk_surface_get_display (surface);
EGLSurface egl_surface;
gdk/gdkglcontext: include duration of eglSwapBuffers
2024-03-02 00:03:57 +00:00
G_GNUC_UNUSED gint64 begin_time = GDK_PROFILER_CURRENT_TIME;
egl: Unify contexts Unify the X11 and Wayland EGL contexts. This is a bit ugly to implement, because I don't want to create an interface and I can't make them inherit from the same object, because one needs to inherit from X11GLContext and the other from WaylandGLContext. So we have to put the code in GdkGLContext and make sure non-EGL contexts can't accidentally run it. This is rather easy because we can just check for priv->egl_context != NULL.
2021-10-05 22:34:10 +00:00
if (priv->egl_context == NULL)
return;
gdk_gl_context_make_current (context);
egl_surface = gdk_surface_get_egl_surface (surface);
gdk: use EGL_KHR_swap_buffers_with_damage It appears that NVIDIA does not implement EGL_EXT_swap_buffers_with_damage on their EGL implementation, but does implement the KHR variant of it. This checks for a suitable implementation and stores a pointer to the compatible implementation within the GdkGLContextPrivate struct.
2022-03-03 06:59:23 +00:00
if (priv->eglSwapBuffersWithDamage)
egl: Unify contexts Unify the X11 and Wayland EGL contexts. This is a bit ugly to implement, because I don't want to create an interface and I can't make them inherit from the same object, because one needs to inherit from X11GLContext and the other from WaylandGLContext. So we have to put the code in GdkGLContext and make sure non-EGL contexts can't accidentally run it. This is rather easy because we can just check for priv->egl_context != NULL.
2021-10-05 22:34:10 +00:00
{
EGLint stack_rects[4 * 4]; /* 4 rects */
EGLint *heap_rects = NULL;
int i, j, n_rects = cairo_region_num_rectangles (painted);
int surface_height = gdk_surface_get_height (surface);
Make fractional scaling for GL opt-in Fractional scaling with the GL renderer is experimental for now, so we disable it unless GDK_DEBUG=gl-fractional is set. This will give us time to work out the kinks.
2023-04-02 14:24:37 +00:00
double scale = gdk_gl_context_get_scale (context);
egl: Unify contexts Unify the X11 and Wayland EGL contexts. This is a bit ugly to implement, because I don't want to create an interface and I can't make them inherit from the same object, because one needs to inherit from X11GLContext and the other from WaylandGLContext. So we have to put the code in GdkGLContext and make sure non-EGL contexts can't accidentally run it. This is rather easy because we can just check for priv->egl_context != NULL.
2021-10-05 22:34:10 +00:00
EGLint *rects;
if (n_rects < G_N_ELEMENTS (stack_rects) / 4)
rects = (EGLint *)&stack_rects;
else
heap_rects = rects = g_new (EGLint, n_rects * 4);
for (i = 0, j = 0; i < n_rects; i++)
{
cairo_rectangle_int_t rect;
cairo_region_get_rectangle (painted, i, &rect);
Use fractional scale for the GL renderer This commit combines changes in the Wayland backend, the GL context frontend, and the GL renderer to switch them all to use the fractional scale. In the Wayland backend, we now use the fractional scale to size the EGL window. In the GL frontend code, we use the fractional scale to scale the damage region and surface in begin/end_frame. And in the GL renderer, we replace gdk_surface_get_scale_factor() with gdk_surface_get_scale().
2023-04-02 02:52:13 +00:00
rects[j++] = (int) floor (rect.x * scale);
rects[j++] = (int) floor ((surface_height - rect.height - rect.y) * scale);
rects[j++] = (int) ceil (rect.width * scale);
rects[j++] = (int) ceil (rect.height * scale);
egl: Unify contexts Unify the X11 and Wayland EGL contexts. This is a bit ugly to implement, because I don't want to create an interface and I can't make them inherit from the same object, because one needs to inherit from X11GLContext and the other from WaylandGLContext. So we have to put the code in GdkGLContext and make sure non-EGL contexts can't accidentally run it. This is rather easy because we can just check for priv->egl_context != NULL.
2021-10-05 22:34:10 +00:00
}
gdk: use EGL_KHR_swap_buffers_with_damage It appears that NVIDIA does not implement EGL_EXT_swap_buffers_with_damage on their EGL implementation, but does implement the KHR variant of it. This checks for a suitable implementation and stores a pointer to the compatible implementation within the GdkGLContextPrivate struct.
2022-03-03 06:59:23 +00:00
priv->eglSwapBuffersWithDamage (gdk_display_get_egl_display (display), egl_surface, rects, n_rects);
egl: Unify contexts Unify the X11 and Wayland EGL contexts. This is a bit ugly to implement, because I don't want to create an interface and I can't make them inherit from the same object, because one needs to inherit from X11GLContext and the other from WaylandGLContext. So we have to put the code in GdkGLContext and make sure non-EGL contexts can't accidentally run it. This is rather easy because we can just check for priv->egl_context != NULL.
2021-10-05 22:34:10 +00:00
g_free (heap_rects);
}
else
eglSwapBuffers (gdk_display_get_egl_display (display), egl_surface);
#endif
gdk/gdkglcontext: include duration of eglSwapBuffers
2024-03-02 00:03:57 +00:00
gdk_profiler_add_mark (begin_time, GDK_PROFILER_CURRENT_TIME - begin_time, "EGL swap buffers", NULL);
glcontext: Store the buffer age regions in the GL context That way, we can store the right region there: The actual painted area instead of the exposed area (which is way too small). Also, the GL context is the only user of this data, so storing it there seems way smarter.
2018-04-08 22:58:31 +00:00
}
static void
gdk_gl_context_surface_resized (GdkDrawContext *draw_context)
{
GdkGLContext *context = GDK_GL_CONTEXT (draw_context);
gdk_gl_context_clear_old_updated_area (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
}
gsk/gl: support non-standard default framebuffer There are situations where our "default framebuffer" is not actually zero, yet we still want to apply a scissor rect. Generally, 0 is the default framebuffer. But on platforms where we need to bind a platform-specific feature to a GL_FRAMEBUFFER, we might have a default that is not 0. For example, on macOS we bind an IOSurfaceRef to a GL_TEXTURE_RECTANGLE which then is assigned as the backing store for a framebuffer. This is different than using gsk_gl_renderer_render_texture() in that we don't want to incur an extra copy to the destination surface nor do we even have a way to pass a texture_id into render_texture().
2022-02-11 05:51:15 +00:00
static guint
gdk_gl_context_real_get_default_framebuffer (GdkGLContext *self)
{
return 0;
}
gdk: Add support for OpenGL This adds the new type GdkGLContext that wraps an OpenGL context for a particular native window. It also adds support for the gdk paint machinery to use OpenGL to draw everything. As soon as anyone creates a GL context for a native window we create a "paint context" for that GdkWindow and switch to using GL for painting it. This commit contains only an implementation for X11 (using GLX). The way painting works is that all client gl contexts draw into offscreen buffers rather than directly to the back buffer, and the way something gets onto the window is by using gdk_cairo_draw_from_gl() to draw part of that buffer onto the draw cairo context. As a fallback (if we're doing redirected drawing or some effect like a cairo_push_group()) we read back the gl buffer into memory and composite using cairo. This means that GL rendering works in all cases, including rendering to a PDF. However, this is not particularly fast. In the *typical* case, where we're drawing directly to the window in the regular paint loop we hit the fast path. The fast path uses opengl to draw the buffer to the window back buffer, either by blitting or texturing. Then we track the region that was drawn, and when the draw ends we paint the normal cairo surface to the window (using texture-from-pixmap in the X11 case, or texture from cairo image otherwise) in the regions where there is no gl painted. There are some complexities wrt layering of gl and cairo areas though: * We track via gdk_window_mark_paint_from_clip() whenever gtk is painting over a region we previously rendered with opengl (flushed_region). This area (needs_blend_region) is blended rather than copied at the end of the frame. * If we're drawing a gl texture with alpha we first copy the current cairo_surface inside the target region to the back buffer before we blend over it. These two operations allow us full stacking of transparent gl and cairo regions.
2014-10-09 08:45:44 +00:00
static void
gdk_gl_context_class_init (GdkGLContextClass *klass)
{
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);
gdk: Add support for OpenGL This adds the new type GdkGLContext that wraps an OpenGL context for a particular native window. It also adds support for the gdk paint machinery to use OpenGL to draw everything. As soon as anyone creates a GL context for a native window we create a "paint context" for that GdkWindow and switch to using GL for painting it. This commit contains only an implementation for X11 (using GLX). The way painting works is that all client gl contexts draw into offscreen buffers rather than directly to the back buffer, and the way something gets onto the window is by using gdk_cairo_draw_from_gl() to draw part of that buffer onto the draw cairo context. As a fallback (if we're doing redirected drawing or some effect like a cairo_push_group()) we read back the gl buffer into memory and composite using cairo. This means that GL rendering works in all cases, including rendering to a PDF. However, this is not particularly fast. In the *typical* case, where we're drawing directly to the window in the regular paint loop we hit the fast path. The fast path uses opengl to draw the buffer to the window back buffer, either by blitting or texturing. Then we track the region that was drawn, and when the draw ends we paint the normal cairo surface to the window (using texture-from-pixmap in the X11 case, or texture from cairo image otherwise) in the regions where there is no gl painted. There are some complexities wrt layering of gl and cairo areas though: * We track via gdk_window_mark_paint_from_clip() whenever gtk is painting over a region we previously rendered with opengl (flushed_region). This area (needs_blend_region) is blended rather than copied at the end of the frame. * If we're drawing a gl texture with alpha we first copy the current cairo_surface inside the target region to the back buffer before we blend over it. These two operations allow us full stacking of transparent gl and cairo regions.
2014-10-09 08:45:44 +00:00
glcontext: Make the creation of EGL context more obvious By splitting it into its own function it becomes more that the EGL code is a shared implementation.
2022-05-06 14:40:13 +00:00
klass->realize = gdk_gl_context_default_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
klass->get_damage = gdk_gl_context_real_get_damage;
gdk: Add gdk_gl_context_is_shared() ... and use it in the GL renderers.
2021-06-30 02:52:35 +00:00
klass->is_shared = gdk_gl_context_real_is_shared;
egl: Unify contexts Unify the X11 and Wayland EGL contexts. This is a bit ugly to implement, because I don't want to create an interface and I can't make them inherit from the same object, because one needs to inherit from X11GLContext and the other from WaylandGLContext. So we have to put the code in GdkGLContext and make sure non-EGL contexts can't accidentally run it. This is rather easy because we can just check for priv->egl_context != NULL.
2021-10-05 22:34:10 +00:00
klass->make_current = gdk_gl_context_real_make_current;
klass->clear_current = gdk_gl_context_real_clear_current;
gdk: Add private GLContext::is_current() check ... and use this check in gdk_gl_context_make_current() and gdk_gl_context_get_current() to make sure the context really is still current. The context no longer being current can happen when external GL implementations make their own contexts current in the same threads GDK contexts are used in. And that can happen for example by WebKit. Theoretically, this should also allow external EGL code to run in X11 applications when GDK chooses to use GLX, but I didn't try it. Fixes #5392
2023-02-02 01:49:56 +00:00
klass->is_current = gdk_gl_context_real_is_current;
gsk/gl: support non-standard default framebuffer There are situations where our "default framebuffer" is not actually zero, yet we still want to apply a scissor rect. Generally, 0 is the default framebuffer. But on platforms where we need to bind a platform-specific feature to a GL_FRAMEBUFFER, we might have a default that is not 0. For example, on macOS we bind an IOSurfaceRef to a GL_TEXTURE_RECTANGLE which then is assigned as the backing store for a framebuffer. This is different than using gsk_gl_renderer_render_texture() in that we don't want to incur an extra copy to the destination surface nor do we even have a way to pass a texture_id into render_texture().
2022-02-11 05:51:15 +00:00
klass->get_default_framebuffer = gdk_gl_context_real_get_default_framebuffer;
gl: Add a realize() fallback Calling gdk_gl_context_realize() should always result in a valid result, so we need to provide a default implementation, to avoid a call to a NULL function pointer.
2016-05-23 07:31:47 +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
draw_context_class->begin_frame = gdk_gl_context_real_begin_frame;
draw_context_class->end_frame = gdk_gl_context_real_end_frame;
glcontext: Store the buffer age regions in the GL context That way, we can store the right region there: The actual painted area instead of the exposed area (which is way too small). Also, the GL context is the only user of this data, so storing it there seems way smarter.
2018-04-08 22:58:31 +00:00
draw_context_class->surface_resized = gdk_gl_context_surface_resized;
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: 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
/**
glcontext: Add property annotations Connect properties, getters, and setters with annotations.
2021-02-25 01:04:17 +00:00
* GdkGLContext:shared-context: (attributes org.gtk.Property.get=gdk_gl_context_get_shared_context)
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
*
gl: Deprecate gdk_gl_context_get_shared_context() It's not used anymore. And in particular we do want to keep the display context private, so we're not gonna return it from this function.
2021-07-10 01:24:00 +00:00
* Always %NULL
*
* As many contexts can share data now and no single shared context exists
* anymore, this function has been deprecated and now always returns %NULL.
*
* Deprecated: 4.4: Use [method@Gdk.GLContext.is_shared] to check if contexts
* can be shared.
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
*/
glcontext: Add GdkGLContext::allowed-apis This allows specifying the GL APIs in a more comprehensive way than gdk_gl_context_set_use_es().
2021-10-07 15:59:17 +00:00
properties[PROP_SHARED_CONTEXT] =
Remove all nicks and blurbs from param specs Those property features don't seem to be in use anywhere. They are redundant since the docs cover the same information and more. They also created unnecessary translation work. Closes #4904
2022-05-11 12:19:39 +00:00
g_param_spec_object ("shared-context", NULL, NULL,
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
GDK_TYPE_GL_CONTEXT,
G_PARAM_READWRITE |
G_PARAM_CONSTRUCT_ONLY |
gl: Deprecate gdk_gl_context_get_shared_context() It's not used anymore. And in particular we do want to keep the display context private, so we're not gonna return it from this function.
2021-07-10 01:24:00 +00:00
G_PARAM_STATIC_STRINGS |
G_PARAM_DEPRECATED);
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
glcontext: Add GdkGLContext::allowed-apis This allows specifying the GL APIs in a more comprehensive way than gdk_gl_context_set_use_es().
2021-10-07 15:59:17 +00:00
/**
* GdkGLContext:allowed-apis: (attributes org.gtk.Property.get=gdk_gl_context_get_allowed_apis org.gtk.Property.gdk_gl_context_set_allowed_apis)
*
* The allowed APIs.
*
* Since: 4.6
*/
properties[PROP_ALLOWED_APIS] =
Remove all nicks and blurbs from param specs Those property features don't seem to be in use anywhere. They are redundant since the docs cover the same information and more. They also created unnecessary translation work. Closes #4904
2022-05-11 12:19:39 +00:00
g_param_spec_flags ("allowed-apis", NULL, NULL,
glcontext: Add GdkGLContext::allowed-apis This allows specifying the GL APIs in a more comprehensive way than gdk_gl_context_set_use_es().
2021-10-07 15:59:17 +00:00
GDK_TYPE_GL_API,
DEFAULT_ALLOWED_APIS,
G_PARAM_READWRITE |
G_PARAM_STATIC_STRINGS |
G_PARAM_EXPLICIT_NOTIFY);
glcontext: Add gdk_gl_context_get_api() This is mostly for inspector. Not sure if we also want to deprecate gdk_gl_context_get_use_es() in favor of this function.
2021-10-07 21:03:45 +00:00
/**
* GdkGLContext:api: (attributes org.gtk.Property.get=gdk_gl_context_get_api)
*
* The API currently in use.
*
* Since: 4.6
*/
properties[PROP_API] =
Remove all nicks and blurbs from param specs Those property features don't seem to be in use anywhere. They are redundant since the docs cover the same information and more. They also created unnecessary translation work. Closes #4904
2022-05-11 12:19:39 +00:00
g_param_spec_flags ("api", NULL, NULL,
glcontext: Add gdk_gl_context_get_api() This is mostly for inspector. Not sure if we also want to deprecate gdk_gl_context_get_use_es() in favor of this function.
2021-10-07 21:03:45 +00:00
GDK_TYPE_GL_API,
0,
G_PARAM_READABLE |
G_PARAM_STATIC_STRINGS |
G_PARAM_EXPLICIT_NOTIFY);
gdk: Add support for OpenGL This adds the new type GdkGLContext that wraps an OpenGL context for a particular native window. It also adds support for the gdk paint machinery to use OpenGL to draw everything. As soon as anyone creates a GL context for a native window we create a "paint context" for that GdkWindow and switch to using GL for painting it. This commit contains only an implementation for X11 (using GLX). The way painting works is that all client gl contexts draw into offscreen buffers rather than directly to the back buffer, and the way something gets onto the window is by using gdk_cairo_draw_from_gl() to draw part of that buffer onto the draw cairo context. As a fallback (if we're doing redirected drawing or some effect like a cairo_push_group()) we read back the gl buffer into memory and composite using cairo. This means that GL rendering works in all cases, including rendering to a PDF. However, this is not particularly fast. In the *typical* case, where we're drawing directly to the window in the regular paint loop we hit the fast path. The fast path uses opengl to draw the buffer to the window back buffer, either by blitting or texturing. Then we track the region that was drawn, and when the draw ends we paint the normal cairo surface to the window (using texture-from-pixmap in the X11 case, or texture from cairo image otherwise) in the regions where there is no gl painted. There are some complexities wrt layering of gl and cairo areas though: * We track via gdk_window_mark_paint_from_clip() whenever gtk is painting over a region we previously rendered with opengl (flushed_region). This area (needs_blend_region) is blended rather than copied at the end of the frame. * If we're drawing a gl texture with alpha we first copy the current cairo_surface inside the target region to the back buffer before we blend over it. These two operations allow us full stacking of transparent gl and cairo regions.
2014-10-09 08:45:44 +00:00
gobject_class->set_property = gdk_gl_context_set_property;
gobject_class->get_property = gdk_gl_context_get_property;
gobject_class->dispose = gdk_gl_context_dispose;
glcontext: Add GdkGLContext::allowed-apis This allows specifying the GL APIs in a more comprehensive way than gdk_gl_context_set_use_es().
2021-10-07 15:59:17 +00:00
g_object_class_install_properties (gobject_class, LAST_PROP, properties);
gdk: Add support for OpenGL This adds the new type GdkGLContext that wraps an OpenGL context for a particular native window. It also adds support for the gdk paint machinery to use OpenGL to draw everything. As soon as anyone creates a GL context for a native window we create a "paint context" for that GdkWindow and switch to using GL for painting it. This commit contains only an implementation for X11 (using GLX). The way painting works is that all client gl contexts draw into offscreen buffers rather than directly to the back buffer, and the way something gets onto the window is by using gdk_cairo_draw_from_gl() to draw part of that buffer onto the draw cairo context. As a fallback (if we're doing redirected drawing or some effect like a cairo_push_group()) we read back the gl buffer into memory and composite using cairo. This means that GL rendering works in all cases, including rendering to a PDF. However, this is not particularly fast. In the *typical* case, where we're drawing directly to the window in the regular paint loop we hit the fast path. The fast path uses opengl to draw the buffer to the window back buffer, either by blitting or texturing. Then we track the region that was drawn, and when the draw ends we paint the normal cairo surface to the window (using texture-from-pixmap in the X11 case, or texture from cairo image otherwise) in the regions where there is no gl painted. There are some complexities wrt layering of gl and cairo areas though: * We track via gdk_window_mark_paint_from_clip() whenever gtk is painting over a region we previously rendered with opengl (flushed_region). This area (needs_blend_region) is blended rather than copied at the end of the frame. * If we're drawing a gl texture with alpha we first copy the current cairo_surface inside the target region to the back buffer before we blend over it. These two operations allow us full stacking of transparent gl and cairo regions.
2014-10-09 08:45:44 +00:00
}
static void
gdk_gl_context_init (GdkGLContext *self)
{
gdk/gl: Allow autodetection for GL/GLES If the GdkGLContext was not explicitly instructed to use or not GLES, we can detect whether the underlying API is going to be desktop GL or GLES. https://bugzilla.gnome.org/show_bug.cgi?id=773180
2016-10-19 12:43:17 +00:00
GdkGLContextPrivate *priv = gdk_gl_context_get_instance_private (self);
glcontext: Add GdkGLContext::allowed-apis This allows specifying the GL APIs in a more comprehensive way than gdk_gl_context_set_use_es().
2021-10-07 15:59:17 +00:00
priv->allowed_apis = DEFAULT_ALLOWED_APIS;
gdk: Add support for OpenGL This adds the new type GdkGLContext that wraps an OpenGL context for a particular native window. It also adds support for the gdk paint machinery to use OpenGL to draw everything. As soon as anyone creates a GL context for a native window we create a "paint context" for that GdkWindow and switch to using GL for painting it. This commit contains only an implementation for X11 (using GLX). The way painting works is that all client gl contexts draw into offscreen buffers rather than directly to the back buffer, and the way something gets onto the window is by using gdk_cairo_draw_from_gl() to draw part of that buffer onto the draw cairo context. As a fallback (if we're doing redirected drawing or some effect like a cairo_push_group()) we read back the gl buffer into memory and composite using cairo. This means that GL rendering works in all cases, including rendering to a PDF. However, this is not particularly fast. In the *typical* case, where we're drawing directly to the window in the regular paint loop we hit the fast path. The fast path uses opengl to draw the buffer to the window back buffer, either by blitting or texturing. Then we track the region that was drawn, and when the draw ends we paint the normal cairo surface to the window (using texture-from-pixmap in the X11 case, or texture from cairo image otherwise) in the regions where there is no gl painted. There are some complexities wrt layering of gl and cairo areas though: * We track via gdk_window_mark_paint_from_clip() whenever gtk is painting over a region we previously rendered with opengl (flushed_region). This area (needs_blend_region) is blended rather than copied at the end of the frame. * If we're drawing a gl texture with alpha we first copy the current cairo_surface inside the target region to the back buffer before we blend over it. These two operations allow us full stacking of transparent gl and cairo regions.
2014-10-09 08:45:44 +00:00
}
gdk: Move GL context construction to GdkGLContext Now that we have the display's context to hook into, we can use it to construct other GL contexts and don't need a GdkSurface vfunc anymore. This has the added benefit that backends can have different GdkGLContext classes on the display and get new GLContexts generated from them, so we get multiple GL backend support per GDK backend for free. I originally wanted to make this a vfunc on GdkGLContextClass, but it turns out all the abckends would just call g_object_new() anyway.
2021-07-09 00:50:32 +00:00
/* Must have called gdk_display_prepare_gl() before */
GdkGLContext *
API: Add gdk_display_create_gl_context() This is an alternative to gdk_surface_create_gl_context() when the context is meant to only draw to textures. This is useful in the testsuite or in GStreamer or with GLArea, basically whenever we want to do GL stuff but don't need to actually draw anything on screen. A bunch of code will need to be updated to deal with context->surface being NULL.
2021-10-20 18:03:00 +00:00
gdk_gl_context_new (GdkDisplay *display,
GdkSurface *surface)
gdk: Move GL context construction to GdkGLContext Now that we have the display's context to hook into, we can use it to construct other GL contexts and don't need a GdkSurface vfunc anymore. This has the added benefit that backends can have different GdkGLContext classes on the display and get new GLContexts generated from them, so we get multiple GL backend support per GDK backend for free. I originally wanted to make this a vfunc on GdkGLContextClass, but it turns out all the abckends would just call g_object_new() anyway.
2021-07-09 00:50:32 +00:00
{
API: Add gdk_display_create_gl_context() This is an alternative to gdk_surface_create_gl_context() when the context is meant to only draw to textures. This is useful in the testsuite or in GStreamer or with GLArea, basically whenever we want to do GL stuff but don't need to actually draw anything on screen. A bunch of code will need to be updated to deal with context->surface being NULL.
2021-10-20 18:03:00 +00:00
GdkGLContext *shared;
g_assert (surface == NULL || display == gdk_surface_get_display (surface));
gdk: Move GL context construction to GdkGLContext Now that we have the display's context to hook into, we can use it to construct other GL contexts and don't need a GdkSurface vfunc anymore. This has the added benefit that backends can have different GdkGLContext classes on the display and get new GLContexts generated from them, so we get multiple GL backend support per GDK backend for free. I originally wanted to make this a vfunc on GdkGLContextClass, but it turns out all the abckends would just call g_object_new() anyway.
2021-07-09 00:50:32 +00:00
/* assert gdk_display_prepare_gl() had been called */
API: Add gdk_display_create_gl_context() This is an alternative to gdk_surface_create_gl_context() when the context is meant to only draw to textures. This is useful in the testsuite or in GStreamer or with GLArea, basically whenever we want to do GL stuff but don't need to actually draw anything on screen. A bunch of code will need to be updated to deal with context->surface being NULL.
2021-10-20 18:03:00 +00:00
shared = gdk_display_get_gl_context (display);
gdk: Move GL context construction to GdkGLContext Now that we have the display's context to hook into, we can use it to construct other GL contexts and don't need a GdkSurface vfunc anymore. This has the added benefit that backends can have different GdkGLContext classes on the display and get new GLContexts generated from them, so we get multiple GL backend support per GDK backend for free. I originally wanted to make this a vfunc on GdkGLContextClass, but it turns out all the abckends would just call g_object_new() anyway.
2021-07-09 00:50:32 +00:00
g_assert (shared);
return g_object_new (G_OBJECT_TYPE (shared),
API: Add gdk_display_create_gl_context() This is an alternative to gdk_surface_create_gl_context() when the context is meant to only draw to textures. This is useful in the testsuite or in GStreamer or with GLArea, basically whenever we want to do GL stuff but don't need to actually draw anything on screen. A bunch of code will need to be updated to deal with context->surface being NULL.
2021-10-20 18:03:00 +00:00
"display", display,
gdk: Move GL context construction to GdkGLContext Now that we have the display's context to hook into, we can use it to construct other GL contexts and don't need a GdkSurface vfunc anymore. This has the added benefit that backends can have different GdkGLContext classes on the display and get new GLContexts generated from them, so we get multiple GL backend support per GDK backend for free. I originally wanted to make this a vfunc on GdkGLContextClass, but it turns out all the abckends would just call g_object_new() anyway.
2021-07-09 00:50:32 +00:00
"surface", surface,
NULL);
}
GdkGLContext: Add internal functions for KHR_DEBUG calls This includes pushing and poping debug group messages and labeling objects.
2019-04-24 11:25:46 +00:00
void
gdk_gl_context_push_debug_group (GdkGLContext *context,
const char *message)
{
GdkGLContextPrivate *priv = gdk_gl_context_get_instance_private (context);
gdkglcontext: Only emit opengl debug calls if GDK_DEBUG=gl-debug This avoids a potential performance cost in the non-debug case.
2019-04-24 13:23:32 +00:00
if (priv->use_khr_debug)
GdkGLContext: Add internal functions for KHR_DEBUG calls This includes pushing and poping debug group messages and labeling objects.
2019-04-24 11:25:46 +00:00
glPushDebugGroupKHR (GL_DEBUG_SOURCE_APPLICATION, 0, -1, message);
}
void
gdk_gl_context_push_debug_group_printf (GdkGLContext *context,
const char *format,
...)
{
GdkGLContextPrivate *priv = gdk_gl_context_get_instance_private (context);
Replace "gchar" with "char"
2020-07-24 18:40:36 +00:00
char *message;
GdkGLContext: Add internal functions for KHR_DEBUG calls This includes pushing and poping debug group messages and labeling objects.
2019-04-24 11:25:46 +00:00
va_list args;
gdkglcontext: Only emit opengl debug calls if GDK_DEBUG=gl-debug This avoids a potential performance cost in the non-debug case.
2019-04-24 13:23:32 +00:00
if (priv->use_khr_debug)
GdkGLContext: Add internal functions for KHR_DEBUG calls This includes pushing and poping debug group messages and labeling objects.
2019-04-24 11:25:46 +00:00
{
gdkglcontext: Limit gl debug label length There's a maximum length we have to adhere to, otherwise GL throws a GL_INVALID_VALUE error.
2019-04-27 07:49:41 +00:00
int msg_len;
GdkGLContext: Add internal functions for KHR_DEBUG calls This includes pushing and poping debug group messages and labeling objects.
2019-04-24 11:25:46 +00:00
va_start (args, format);
message = g_strdup_vprintf (format, args);
va_end (args);
gdkglcontext: Limit gl debug label length There's a maximum length we have to adhere to, otherwise GL throws a GL_INVALID_VALUE error.
2019-04-27 07:49:41 +00:00
msg_len = MIN (priv->max_debug_label_length, strlen (message) - 1);
glPushDebugGroupKHR (GL_DEBUG_SOURCE_APPLICATION, 0, msg_len, message);
GdkGLContext: Add internal functions for KHR_DEBUG calls This includes pushing and poping debug group messages and labeling objects.
2019-04-24 11:25:46 +00:00
g_free (message);
}
}
void
gdk_gl_context_pop_debug_group (GdkGLContext *context)
{
GdkGLContextPrivate *priv = gdk_gl_context_get_instance_private (context);
gdkglcontext: Only emit opengl debug calls if GDK_DEBUG=gl-debug This avoids a potential performance cost in the non-debug case.
2019-04-24 13:23:32 +00:00
if (priv->use_khr_debug)
GdkGLContext: Add internal functions for KHR_DEBUG calls This includes pushing and poping debug group messages and labeling objects.
2019-04-24 11:25:46 +00:00
glPopDebugGroupKHR ();
}
void
gdk_gl_context_label_object (GdkGLContext *context,
guint identifier,
guint name,
const char *label)
{
GdkGLContextPrivate *priv = gdk_gl_context_get_instance_private (context);
gdkglcontext: Only emit opengl debug calls if GDK_DEBUG=gl-debug This avoids a potential performance cost in the non-debug case.
2019-04-24 13:23:32 +00:00
if (priv->use_khr_debug)
GdkGLContext: Add internal functions for KHR_DEBUG calls This includes pushing and poping debug group messages and labeling objects.
2019-04-24 11:25:46 +00:00
glObjectLabel (identifier, name, -1, label);
}
void
gdk_gl_context_label_object_printf (GdkGLContext *context,
guint identifier,
guint name,
const char *format,
...)
{
GdkGLContextPrivate *priv = gdk_gl_context_get_instance_private (context);
Replace "gchar" with "char"
2020-07-24 18:40:36 +00:00
char *message;
GdkGLContext: Add internal functions for KHR_DEBUG calls This includes pushing and poping debug group messages and labeling objects.
2019-04-24 11:25:46 +00:00
va_list args;
gdkglcontext: Only emit opengl debug calls if GDK_DEBUG=gl-debug This avoids a potential performance cost in the non-debug case.
2019-04-24 13:23:32 +00:00
if (priv->use_khr_debug)
GdkGLContext: Add internal functions for KHR_DEBUG calls This includes pushing and poping debug group messages and labeling objects.
2019-04-24 11:25:46 +00:00
{
gdkglcontext: Limit gl debug label length There's a maximum length we have to adhere to, otherwise GL throws a GL_INVALID_VALUE error.
2019-04-27 07:49:41 +00:00
int msg_len;
GdkGLContext: Add internal functions for KHR_DEBUG calls This includes pushing and poping debug group messages and labeling objects.
2019-04-24 11:25:46 +00:00
va_start (args, format);
message = g_strdup_vprintf (format, args);
va_end (args);
gdkglcontext: Limit gl debug label length There's a maximum length we have to adhere to, otherwise GL throws a GL_INVALID_VALUE error.
2019-04-27 07:49:41 +00:00
msg_len = MIN (priv->max_debug_label_length, strlen (message) - 1);
glObjectLabel (identifier, name, msg_len, message);
GdkGLContext: Add internal functions for KHR_DEBUG calls This includes pushing and poping debug group messages and labeling objects.
2019-04-24 11:25:46 +00:00
g_free (message);
}
}
gl: Add more OpenGL ES checks Check for the appropriate extensions depending on which type of API we're using.
2016-04-22 16:27:04 +00:00
gboolean
gdk_gl_context_has_unpack_subimage (GdkGLContext *context)
{
GdkGLContextPrivate *priv = gdk_gl_context_get_instance_private (context);
return priv->has_unpack_subimage;
}
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 gboolean
gdk_gl_context_is_realized (GdkGLContext *context)
{
GdkGLContextPrivate *priv = gdk_gl_context_get_instance_private (context);
return priv->api != 0;
}
gl: Add context options Users of the GdkGLContext API should be allowed to set properties on the shim GdkGLContext instance prior to realization, so that the backend-specific implementation can use the value of those properties when creating the windowing system specific resources. The main three options are: • a major/minor version tuple, to request a specific GL version • a debug bit, to request a "debug context", which provides additional validation and run time checking • a forward compatibility bit, to request a context that does not have deprecated functionality See also: - https://www.opengl.org/registry/specs/ARB/glx_create_context.txt https://bugzilla.gnome.org/show_bug.cgi?id=741946
2015-01-28 09:34:16 +00:00
/**
* gdk_gl_context_set_debug_enabled:
docs: Rework the gdk docs Convert links, make things more concise.
2021-02-21 05:13:57 +00:00
* @context: a `GdkGLContext`
gl: Add context options Users of the GdkGLContext API should be allowed to set properties on the shim GdkGLContext instance prior to realization, so that the backend-specific implementation can use the value of those properties when creating the windowing system specific resources. The main three options are: • a major/minor version tuple, to request a specific GL version • a debug bit, to request a "debug context", which provides additional validation and run time checking • a forward compatibility bit, to request a context that does not have deprecated functionality See also: - https://www.opengl.org/registry/specs/ARB/glx_create_context.txt https://bugzilla.gnome.org/show_bug.cgi?id=741946
2015-01-28 09:34:16 +00:00
* @enabled: whether to enable debugging in the context
*
docs: Rework the gdk docs Convert links, make things more concise.
2021-02-21 05:13:57 +00:00
* Sets whether the `GdkGLContext` should perform extra validations and
* runtime checking.
gl: Add context options Users of the GdkGLContext API should be allowed to set properties on the shim GdkGLContext instance prior to realization, so that the backend-specific implementation can use the value of those properties when creating the windowing system specific resources. The main three options are: • a major/minor version tuple, to request a specific GL version • a debug bit, to request a "debug context", which provides additional validation and run time checking • a forward compatibility bit, to request a context that does not have deprecated functionality See also: - https://www.opengl.org/registry/specs/ARB/glx_create_context.txt https://bugzilla.gnome.org/show_bug.cgi?id=741946
2015-01-28 09:34:16 +00:00
*
docs: Rework the gdk docs Convert links, make things more concise.
2021-02-21 05:13:57 +00:00
* This is useful during development, but has additional overhead.
*
* The `GdkGLContext` must not be realized or made current prior to
docs: We do not support non-core GL profiles No need to mention that some API only works on core GL profiles in the GdkGLContext docs. https://bugzilla.gnome.org/show_bug.cgi?id=741946
2015-02-09 16:09:25 +00:00
* calling this function.
gl: Add context options Users of the GdkGLContext API should be allowed to set properties on the shim GdkGLContext instance prior to realization, so that the backend-specific implementation can use the value of those properties when creating the windowing system specific resources. The main three options are: • a major/minor version tuple, to request a specific GL version • a debug bit, to request a "debug context", which provides additional validation and run time checking • a forward compatibility bit, to request a context that does not have deprecated functionality See also: - https://www.opengl.org/registry/specs/ARB/glx_create_context.txt https://bugzilla.gnome.org/show_bug.cgi?id=741946
2015-01-28 09:34:16 +00:00
*/
void
gdk_gl_context_set_debug_enabled (GdkGLContext *context,
gboolean enabled)
{
GdkGLContextPrivate *priv = gdk_gl_context_get_instance_private (context);
g_return_if_fail (GDK_IS_GL_CONTEXT (context));
glcontext: Reinstate missing "!" Replacing the return_if_fail()s in commit f584d4f50025 lost the inversions. Fixes #4349
2021-10-16 13:47:05 +00:00
g_return_if_fail (!gdk_gl_context_is_realized (context));
gl: Add context options Users of the GdkGLContext API should be allowed to set properties on the shim GdkGLContext instance prior to realization, so that the backend-specific implementation can use the value of those properties when creating the windowing system specific resources. The main three options are: • a major/minor version tuple, to request a specific GL version • a debug bit, to request a "debug context", which provides additional validation and run time checking • a forward compatibility bit, to request a context that does not have deprecated functionality See also: - https://www.opengl.org/registry/specs/ARB/glx_create_context.txt https://bugzilla.gnome.org/show_bug.cgi?id=741946
2015-01-28 09:34:16 +00:00
enabled = !!enabled;
priv->debug_enabled = enabled;
}
gl: Move getters for context options to the public API They can be useful for third party code as well. https://bugzilla.gnome.org/show_bug.cgi?id=741946
2015-01-28 14:37:26 +00:00
/**
gl: Add context options Users of the GdkGLContext API should be allowed to set properties on the shim GdkGLContext instance prior to realization, so that the backend-specific implementation can use the value of those properties when creating the windowing system specific resources. The main three options are: • a major/minor version tuple, to request a specific GL version • a debug bit, to request a "debug context", which provides additional validation and run time checking • a forward compatibility bit, to request a context that does not have deprecated functionality See also: - https://www.opengl.org/registry/specs/ARB/glx_create_context.txt https://bugzilla.gnome.org/show_bug.cgi?id=741946
2015-01-28 09:34:16 +00:00
* gdk_gl_context_get_debug_enabled:
docs: Rework the gdk docs Convert links, make things more concise.
2021-02-21 05:13:57 +00:00
* @context: a `GdkGLContext`
*
* Retrieves whether the context is doing extra validations and runtime checking.
gl: Add context options Users of the GdkGLContext API should be allowed to set properties on the shim GdkGLContext instance prior to realization, so that the backend-specific implementation can use the value of those properties when creating the windowing system specific resources. The main three options are: • a major/minor version tuple, to request a specific GL version • a debug bit, to request a "debug context", which provides additional validation and run time checking • a forward compatibility bit, to request a context that does not have deprecated functionality See also: - https://www.opengl.org/registry/specs/ARB/glx_create_context.txt https://bugzilla.gnome.org/show_bug.cgi?id=741946
2015-01-28 09:34:16 +00:00
*
docs: Rework the gdk docs Convert links, make things more concise.
2021-02-21 05:13:57 +00:00
* See [method@Gdk.GLContext.set_debug_enabled].
gl: Add context options Users of the GdkGLContext API should be allowed to set properties on the shim GdkGLContext instance prior to realization, so that the backend-specific implementation can use the value of those properties when creating the windowing system specific resources. The main three options are: • a major/minor version tuple, to request a specific GL version • a debug bit, to request a "debug context", which provides additional validation and run time checking • a forward compatibility bit, to request a context that does not have deprecated functionality See also: - https://www.opengl.org/registry/specs/ARB/glx_create_context.txt https://bugzilla.gnome.org/show_bug.cgi?id=741946
2015-01-28 09:34:16 +00:00
*
* Returns: %TRUE if debugging is enabled
*/
gboolean
gdk_gl_context_get_debug_enabled (GdkGLContext *context)
{
GdkGLContextPrivate *priv = gdk_gl_context_get_instance_private (context);
gl: Move getters for context options to the public API They can be useful for third party code as well. https://bugzilla.gnome.org/show_bug.cgi?id=741946
2015-01-28 14:37:26 +00:00
g_return_val_if_fail (GDK_IS_GL_CONTEXT (context), FALSE);
gl: Add context options Users of the GdkGLContext API should be allowed to set properties on the shim GdkGLContext instance prior to realization, so that the backend-specific implementation can use the value of those properties when creating the windowing system specific resources. The main three options are: • a major/minor version tuple, to request a specific GL version • a debug bit, to request a "debug context", which provides additional validation and run time checking • a forward compatibility bit, to request a context that does not have deprecated functionality See also: - https://www.opengl.org/registry/specs/ARB/glx_create_context.txt https://bugzilla.gnome.org/show_bug.cgi?id=741946
2015-01-28 09:34:16 +00:00
return priv->debug_enabled;
}
/**
* gdk_gl_context_set_forward_compatible:
docs: Rework the gdk docs Convert links, make things more concise.
2021-02-21 05:13:57 +00:00
* @context: a `GdkGLContext`
* @compatible: whether the context should be forward-compatible
gl: Add context options Users of the GdkGLContext API should be allowed to set properties on the shim GdkGLContext instance prior to realization, so that the backend-specific implementation can use the value of those properties when creating the windowing system specific resources. The main three options are: • a major/minor version tuple, to request a specific GL version • a debug bit, to request a "debug context", which provides additional validation and run time checking • a forward compatibility bit, to request a context that does not have deprecated functionality See also: - https://www.opengl.org/registry/specs/ARB/glx_create_context.txt https://bugzilla.gnome.org/show_bug.cgi?id=741946
2015-01-28 09:34:16 +00:00
*
docs: Rework the gdk docs Convert links, make things more concise.
2021-02-21 05:13:57 +00:00
* Sets whether the `GdkGLContext` should be forward-compatible.
gl: Add context options Users of the GdkGLContext API should be allowed to set properties on the shim GdkGLContext instance prior to realization, so that the backend-specific implementation can use the value of those properties when creating the windowing system specific resources. The main three options are: • a major/minor version tuple, to request a specific GL version • a debug bit, to request a "debug context", which provides additional validation and run time checking • a forward compatibility bit, to request a context that does not have deprecated functionality See also: - https://www.opengl.org/registry/specs/ARB/glx_create_context.txt https://bugzilla.gnome.org/show_bug.cgi?id=741946
2015-01-28 09:34:16 +00:00
*
docs: Rework the gdk docs Convert links, make things more concise.
2021-02-21 05:13:57 +00:00
* Forward-compatible contexts must not support OpenGL functionality that
gl: Add context options Users of the GdkGLContext API should be allowed to set properties on the shim GdkGLContext instance prior to realization, so that the backend-specific implementation can use the value of those properties when creating the windowing system specific resources. The main three options are: • a major/minor version tuple, to request a specific GL version • a debug bit, to request a "debug context", which provides additional validation and run time checking • a forward compatibility bit, to request a context that does not have deprecated functionality See also: - https://www.opengl.org/registry/specs/ARB/glx_create_context.txt https://bugzilla.gnome.org/show_bug.cgi?id=741946
2015-01-28 09:34:16 +00:00
* has been marked as deprecated in the requested version; non-forward
* compatible contexts, on the other hand, must support both deprecated and
* non deprecated functionality.
*
docs: Rework the gdk docs Convert links, make things more concise.
2021-02-21 05:13:57 +00:00
* The `GdkGLContext` must not be realized or made current prior to calling
docs: We do not support non-core GL profiles No need to mention that some API only works on core GL profiles in the GdkGLContext docs. https://bugzilla.gnome.org/show_bug.cgi?id=741946
2015-02-09 16:09:25 +00:00
* this function.
gl: Add context options Users of the GdkGLContext API should be allowed to set properties on the shim GdkGLContext instance prior to realization, so that the backend-specific implementation can use the value of those properties when creating the windowing system specific resources. The main three options are: • a major/minor version tuple, to request a specific GL version • a debug bit, to request a "debug context", which provides additional validation and run time checking • a forward compatibility bit, to request a context that does not have deprecated functionality See also: - https://www.opengl.org/registry/specs/ARB/glx_create_context.txt https://bugzilla.gnome.org/show_bug.cgi?id=741946
2015-01-28 09:34:16 +00:00
*/
void
gdk_gl_context_set_forward_compatible (GdkGLContext *context,
gboolean compatible)
{
GdkGLContextPrivate *priv = gdk_gl_context_get_instance_private (context);
gl: Clean up pre-requisite checks for GdkGLContext setters We don't support non-core profiles. https://bugzilla.gnome.org/show_bug.cgi?id=741946
2015-02-09 16:08:43 +00:00
g_return_if_fail (GDK_IS_GL_CONTEXT (context));
glcontext: Reinstate missing "!" Replacing the return_if_fail()s in commit f584d4f50025 lost the inversions. Fixes #4349
2021-10-16 13:47:05 +00:00
g_return_if_fail (!gdk_gl_context_is_realized (context));
gl: Clean up pre-requisite checks for GdkGLContext setters We don't support non-core profiles. https://bugzilla.gnome.org/show_bug.cgi?id=741946
2015-02-09 16:08:43 +00:00
gl: Add context options Users of the GdkGLContext API should be allowed to set properties on the shim GdkGLContext instance prior to realization, so that the backend-specific implementation can use the value of those properties when creating the windowing system specific resources. The main three options are: • a major/minor version tuple, to request a specific GL version • a debug bit, to request a "debug context", which provides additional validation and run time checking • a forward compatibility bit, to request a context that does not have deprecated functionality See also: - https://www.opengl.org/registry/specs/ARB/glx_create_context.txt https://bugzilla.gnome.org/show_bug.cgi?id=741946
2015-01-28 09:34:16 +00:00
compatible = !!compatible;
priv->forward_compatible = compatible;
}
gl: Move getters for context options to the public API They can be useful for third party code as well. https://bugzilla.gnome.org/show_bug.cgi?id=741946
2015-01-28 14:37:26 +00:00
/**
gl: Add context options Users of the GdkGLContext API should be allowed to set properties on the shim GdkGLContext instance prior to realization, so that the backend-specific implementation can use the value of those properties when creating the windowing system specific resources. The main three options are: • a major/minor version tuple, to request a specific GL version • a debug bit, to request a "debug context", which provides additional validation and run time checking • a forward compatibility bit, to request a context that does not have deprecated functionality See also: - https://www.opengl.org/registry/specs/ARB/glx_create_context.txt https://bugzilla.gnome.org/show_bug.cgi?id=741946
2015-01-28 09:34:16 +00:00
* gdk_gl_context_get_forward_compatible:
docs: Rework the gdk docs Convert links, make things more concise.
2021-02-21 05:13:57 +00:00
* @context: a `GdkGLContext`
*
* Retrieves whether the context is forward-compatible.
gl: Add context options Users of the GdkGLContext API should be allowed to set properties on the shim GdkGLContext instance prior to realization, so that the backend-specific implementation can use the value of those properties when creating the windowing system specific resources. The main three options are: • a major/minor version tuple, to request a specific GL version • a debug bit, to request a "debug context", which provides additional validation and run time checking • a forward compatibility bit, to request a context that does not have deprecated functionality See also: - https://www.opengl.org/registry/specs/ARB/glx_create_context.txt https://bugzilla.gnome.org/show_bug.cgi?id=741946
2015-01-28 09:34:16 +00:00
*
docs: Rework the gdk docs Convert links, make things more concise.
2021-02-21 05:13:57 +00:00
* See [method@Gdk.GLContext.set_forward_compatible].
gl: Add context options Users of the GdkGLContext API should be allowed to set properties on the shim GdkGLContext instance prior to realization, so that the backend-specific implementation can use the value of those properties when creating the windowing system specific resources. The main three options are: • a major/minor version tuple, to request a specific GL version • a debug bit, to request a "debug context", which provides additional validation and run time checking • a forward compatibility bit, to request a context that does not have deprecated functionality See also: - https://www.opengl.org/registry/specs/ARB/glx_create_context.txt https://bugzilla.gnome.org/show_bug.cgi?id=741946
2015-01-28 09:34:16 +00:00
*
docs: Rework the gdk docs Convert links, make things more concise.
2021-02-21 05:13:57 +00:00
* Returns: %TRUE if the context should be forward-compatible
gl: Add context options Users of the GdkGLContext API should be allowed to set properties on the shim GdkGLContext instance prior to realization, so that the backend-specific implementation can use the value of those properties when creating the windowing system specific resources. The main three options are: • a major/minor version tuple, to request a specific GL version • a debug bit, to request a "debug context", which provides additional validation and run time checking • a forward compatibility bit, to request a context that does not have deprecated functionality See also: - https://www.opengl.org/registry/specs/ARB/glx_create_context.txt https://bugzilla.gnome.org/show_bug.cgi?id=741946
2015-01-28 09:34:16 +00:00
*/
gboolean
gdk_gl_context_get_forward_compatible (GdkGLContext *context)
{
GdkGLContextPrivate *priv = gdk_gl_context_get_instance_private (context);
gl: Move getters for context options to the public API They can be useful for third party code as well. https://bugzilla.gnome.org/show_bug.cgi?id=741946
2015-01-28 14:37:26 +00:00
g_return_val_if_fail (GDK_IS_GL_CONTEXT (context), FALSE);
gl: Add context options Users of the GdkGLContext API should be allowed to set properties on the shim GdkGLContext instance prior to realization, so that the backend-specific implementation can use the value of those properties when creating the windowing system specific resources. The main three options are: • a major/minor version tuple, to request a specific GL version • a debug bit, to request a "debug context", which provides additional validation and run time checking • a forward compatibility bit, to request a context that does not have deprecated functionality See also: - https://www.opengl.org/registry/specs/ARB/glx_create_context.txt https://bugzilla.gnome.org/show_bug.cgi?id=741946
2015-01-28 09:34:16 +00:00
return priv->forward_compatible;
}
glcontext: Refactor realize function, fix interaction with shared context
2022-05-06 19:43:30 +00:00
void
glcontext: Compute matching version the simple way Do it all in one function instead of requiring two different ones.
2023-04-25 19:45:31 +00:00
gdk_gl_context_get_matching_version (GdkGLContext *context,
GdkGLAPI api,
gdk: Introduce GdkGLVersion ... and use it. Makes the code simpler.
2023-04-25 17:17:07 +00:00
gboolean legacy,
GdkGLVersion *out_version)
glcontext: Refactor realize function, fix interaction with shared context
2022-05-06 19:43:30 +00:00
{
glcontext: Compute matching version the simple way Do it all in one function instead of requiring two different ones.
2023-04-25 19:45:31 +00:00
GdkGLContextPrivate *priv = gdk_gl_context_get_instance_private (context);
GdkGLVersion min_version;
g_return_if_fail (GDK_IS_GL_CONTEXT (context));
glcontext: Refactor realize function, fix interaction with shared context
2022-05-06 19:43:30 +00:00
if (api == GDK_GL_API_GL)
{
if (legacy)
glcontext: Compute matching version the simple way Do it all in one function instead of requiring two different ones.
2023-04-25 19:45:31 +00:00
min_version = GDK_GL_MIN_GL_LEGACY_VERSION;
glcontext: Refactor realize function, fix interaction with shared context
2022-05-06 19:43:30 +00:00
else
glcontext: Compute matching version the simple way Do it all in one function instead of requiring two different ones.
2023-04-25 19:45:31 +00:00
min_version = GDK_GL_MIN_GL_VERSION;
glcontext: Refactor realize function, fix interaction with shared context
2022-05-06 19:43:30 +00:00
}
else
{
glcontext: Compute matching version the simple way Do it all in one function instead of requiring two different ones.
2023-04-25 19:45:31 +00:00
min_version = GDK_GL_MIN_GLES_VERSION;
glcontext: Refactor realize function, fix interaction with shared context
2022-05-06 19:43:30 +00:00
}
glcontext: Compute matching version the simple way Do it all in one function instead of requiring two different ones.
2023-04-25 19:45:31 +00:00
if (gdk_gl_version_greater_equal (&priv->required, &min_version))
*out_version = priv->required;
else
*out_version = min_version;
glcontext: Refactor realize function, fix interaction with shared context
2022-05-06 19:43:30 +00:00
}
gl: Add context options Users of the GdkGLContext API should be allowed to set properties on the shim GdkGLContext instance prior to realization, so that the backend-specific implementation can use the value of those properties when creating the windowing system specific resources. The main three options are: • a major/minor version tuple, to request a specific GL version • a debug bit, to request a "debug context", which provides additional validation and run time checking • a forward compatibility bit, to request a context that does not have deprecated functionality See also: - https://www.opengl.org/registry/specs/ARB/glx_create_context.txt https://bugzilla.gnome.org/show_bug.cgi?id=741946
2015-01-28 09:34:16 +00:00
/**
* gdk_gl_context_set_required_version:
docs: Rework the gdk docs Convert links, make things more concise.
2021-02-21 05:13:57 +00:00
* @context: a `GdkGLContext`
gl: Add context options Users of the GdkGLContext API should be allowed to set properties on the shim GdkGLContext instance prior to realization, so that the backend-specific implementation can use the value of those properties when creating the windowing system specific resources. The main three options are: • a major/minor version tuple, to request a specific GL version • a debug bit, to request a "debug context", which provides additional validation and run time checking • a forward compatibility bit, to request a context that does not have deprecated functionality See also: - https://www.opengl.org/registry/specs/ARB/glx_create_context.txt https://bugzilla.gnome.org/show_bug.cgi?id=741946
2015-01-28 09:34:16 +00:00
* @major: the major version to request
* @minor: the minor version to request
*
* Sets the major and minor version of OpenGL to request.
*
* Setting @major and @minor to zero will use the default values.
*
glcontext: Do not check for correctness in set_required_version There are two reasons for this: * First, the refactored realize code now makes sure that no context with unsupported version is ever created. * Second, this code could bump into false possitives and negatives, since the user is not requested, nor expected to set_required_version in any specific order relative to set_allowed_apis. Therefore, some version could be rejected or accepted based on a set of allowed apis that the user has not yet correctly configured.
2022-05-25 13:23:38 +00:00
* Setting @major and @minor lower than the minimum versions required
* by GTK will result in the context choosing the minimum version.
*
* The @context must not be realized or made current prior to calling
docs: We do not support non-core GL profiles No need to mention that some API only works on core GL profiles in the GdkGLContext docs. https://bugzilla.gnome.org/show_bug.cgi?id=741946
2015-02-09 16:09:25 +00:00
* this function.
gl: Add context options Users of the GdkGLContext API should be allowed to set properties on the shim GdkGLContext instance prior to realization, so that the backend-specific implementation can use the value of those properties when creating the windowing system specific resources. The main three options are: • a major/minor version tuple, to request a specific GL version • a debug bit, to request a "debug context", which provides additional validation and run time checking • a forward compatibility bit, to request a context that does not have deprecated functionality See also: - https://www.opengl.org/registry/specs/ARB/glx_create_context.txt https://bugzilla.gnome.org/show_bug.cgi?id=741946
2015-01-28 09:34:16 +00:00
*/
void
gdk_gl_context_set_required_version (GdkGLContext *context,
int major,
int minor)
{
GdkGLContextPrivate *priv = gdk_gl_context_get_instance_private (context);
g_return_if_fail (GDK_IS_GL_CONTEXT (context));
glcontext: reinstate another missing "!" A leftover from aa0c22b64813a406da9854fd079579d87181a97b.
2021-10-17 16:46:01 +00:00
g_return_if_fail (!gdk_gl_context_is_realized (context));
gl: Add context options Users of the GdkGLContext API should be allowed to set properties on the shim GdkGLContext instance prior to realization, so that the backend-specific implementation can use the value of those properties when creating the windowing system specific resources. The main three options are: • a major/minor version tuple, to request a specific GL version • a debug bit, to request a "debug context", which provides additional validation and run time checking • a forward compatibility bit, to request a context that does not have deprecated functionality See also: - https://www.opengl.org/registry/specs/ARB/glx_create_context.txt https://bugzilla.gnome.org/show_bug.cgi?id=741946
2015-01-28 09:34:16 +00:00
gdk: Introduce GdkGLVersion ... and use it. Makes the code simpler.
2023-04-25 17:17:07 +00:00
priv->required = GDK_GL_VERSION_INIT (major, minor);
gl: Add context options Users of the GdkGLContext API should be allowed to set properties on the shim GdkGLContext instance prior to realization, so that the backend-specific implementation can use the value of those properties when creating the windowing system specific resources. The main three options are: • a major/minor version tuple, to request a specific GL version • a debug bit, to request a "debug context", which provides additional validation and run time checking • a forward compatibility bit, to request a context that does not have deprecated functionality See also: - https://www.opengl.org/registry/specs/ARB/glx_create_context.txt https://bugzilla.gnome.org/show_bug.cgi?id=741946
2015-01-28 09:34:16 +00:00
}
gl: Move texture uploading to the renderer It does not belong in GdkGLContext, it's a renderer thing. It's also the only user of that API. Introduce gdk_gl_context_check_version() private API to make version checks simpler.
2021-10-12 13:04:43 +00:00
gboolean
glcontext: Use GdkGLVersion elsewhere ... and add a convenience API to generate GL versions from strings to make the gdk_gl_context_check() API nicer.
2023-04-25 17:32:12 +00:00
gdk_gl_context_check_gl_version (GdkGLContext *self,
const GdkGLVersion *required_gl,
const GdkGLVersion *required_gles)
gl: Move texture uploading to the renderer It does not belong in GdkGLContext, it's a renderer thing. It's also the only user of that API. Introduce gdk_gl_context_check_version() private API to make version checks simpler.
2021-10-12 13:04:43 +00:00
{
gl: Change gdk_gl_context_check_version() Instead of just passing major/minor, pass them twice, once for GL and once for GLES. This way, we don't need to check for GL and GLES separately. If something is supported unconditionally, passing 0/0 works fine. That said, I'd like to group the arguments somehow, because otherwise it's just a confusing list of numbers - but I have no idea how to do that.
2021-12-25 13:14:52 +00:00
GdkGLContextPrivate *priv = gdk_gl_context_get_instance_private (self);
gl: Move texture uploading to the renderer It does not belong in GdkGLContext, it's a renderer thing. It's also the only user of that API. Introduce gdk_gl_context_check_version() private API to make version checks simpler.
2021-10-12 13:04:43 +00:00
gl: Change gdk_gl_context_check_version() Instead of just passing major/minor, pass them twice, once for GL and once for GLES. This way, we don't need to check for GL and GLES separately. If something is supported unconditionally, passing 0/0 works fine. That said, I'd like to group the arguments somehow, because otherwise it's just a confusing list of numbers - but I have no idea how to do that.
2021-12-25 13:14:52 +00:00
g_return_val_if_fail (GDK_IS_GL_CONTEXT (self), FALSE);
gl: Move texture uploading to the renderer It does not belong in GdkGLContext, it's a renderer thing. It's also the only user of that API. Introduce gdk_gl_context_check_version() private API to make version checks simpler.
2021-10-12 13:04:43 +00:00
gl: Change gdk_gl_context_check_version() Instead of just passing major/minor, pass them twice, once for GL and once for GLES. This way, we don't need to check for GL and GLES separately. If something is supported unconditionally, passing 0/0 works fine. That said, I'd like to group the arguments somehow, because otherwise it's just a confusing list of numbers - but I have no idea how to do that.
2021-12-25 13:14:52 +00:00
if (!gdk_gl_context_is_realized (self))
return FALSE;
switch (priv->api)
{
case GDK_GL_API_GL:
glcontext: Use GdkGLVersion elsewhere ... and add a convenience API to generate GL versions from strings to make the gdk_gl_context_check() API nicer.
2023-04-25 17:32:12 +00:00
return required_gl == NULL || gdk_gl_version_greater_equal (&priv->gl_version, required_gl);
gl: Change gdk_gl_context_check_version() Instead of just passing major/minor, pass them twice, once for GL and once for GLES. This way, we don't need to check for GL and GLES separately. If something is supported unconditionally, passing 0/0 works fine. That said, I'd like to group the arguments somehow, because otherwise it's just a confusing list of numbers - but I have no idea how to do that.
2021-12-25 13:14:52 +00:00
case GDK_GL_API_GLES:
glcontext: Use GdkGLVersion elsewhere ... and add a convenience API to generate GL versions from strings to make the gdk_gl_context_check() API nicer.
2023-04-25 17:32:12 +00:00
return required_gles == NULL || gdk_gl_version_greater_equal (&priv->gl_version, required_gles);
gl: Change gdk_gl_context_check_version() Instead of just passing major/minor, pass them twice, once for GL and once for GLES. This way, we don't need to check for GL and GLES separately. If something is supported unconditionally, passing 0/0 works fine. That said, I'd like to group the arguments somehow, because otherwise it's just a confusing list of numbers - but I have no idea how to do that.
2021-12-25 13:14:52 +00:00
default:
g_return_val_if_reached (FALSE);
}
gl: Move texture uploading to the renderer It does not belong in GdkGLContext, it's a renderer thing. It's also the only user of that API. Introduce gdk_gl_context_check_version() private API to make version checks simpler.
2021-10-12 13:04:43 +00:00
}
gl: Move getters for context options to the public API They can be useful for third party code as well. https://bugzilla.gnome.org/show_bug.cgi?id=741946
2015-01-28 14:37:26 +00:00
/**
gl: Add context options Users of the GdkGLContext API should be allowed to set properties on the shim GdkGLContext instance prior to realization, so that the backend-specific implementation can use the value of those properties when creating the windowing system specific resources. The main three options are: • a major/minor version tuple, to request a specific GL version • a debug bit, to request a "debug context", which provides additional validation and run time checking • a forward compatibility bit, to request a context that does not have deprecated functionality See also: - https://www.opengl.org/registry/specs/ARB/glx_create_context.txt https://bugzilla.gnome.org/show_bug.cgi?id=741946
2015-01-28 09:34:16 +00:00
* gdk_gl_context_get_required_version:
docs: Rework the gdk docs Convert links, make things more concise.
2021-02-21 05:13:57 +00:00
* @context: a `GdkGLContext`
gl: Add context options Users of the GdkGLContext API should be allowed to set properties on the shim GdkGLContext instance prior to realization, so that the backend-specific implementation can use the value of those properties when creating the windowing system specific resources. The main three options are: • a major/minor version tuple, to request a specific GL version • a debug bit, to request a "debug context", which provides additional validation and run time checking • a forward compatibility bit, to request a context that does not have deprecated functionality See also: - https://www.opengl.org/registry/specs/ARB/glx_create_context.txt https://bugzilla.gnome.org/show_bug.cgi?id=741946
2015-01-28 09:34:16 +00:00
* @major: (out) (nullable): return location for the major version to request
* @minor: (out) (nullable): return location for the minor version to request
*
glcontext: Simplify get_required_version api Simplify the API to just return the requirements that the user has asked for. The rest of the code was undocumented and previously used as a buggy source for a default value from internal code. Since the buggy code is now fixed, remove all unnecessary cruft.
2022-05-30 18:18:15 +00:00
* Retrieves required OpenGL version set as a requirement for the @context
* realization. It will not change even if a greater OpenGL version is supported
* and used after the @context is realized. See
* [method@Gdk.GLContext.get_version] for the real version in use.
docs: Rework the gdk docs Convert links, make things more concise.
2021-02-21 05:13:57 +00:00
*
* See [method@Gdk.GLContext.set_required_version].
gl: Add context options Users of the GdkGLContext API should be allowed to set properties on the shim GdkGLContext instance prior to realization, so that the backend-specific implementation can use the value of those properties when creating the windowing system specific resources. The main three options are: • a major/minor version tuple, to request a specific GL version • a debug bit, to request a "debug context", which provides additional validation and run time checking • a forward compatibility bit, to request a context that does not have deprecated functionality See also: - https://www.opengl.org/registry/specs/ARB/glx_create_context.txt https://bugzilla.gnome.org/show_bug.cgi?id=741946
2015-01-28 09:34:16 +00:00
*/
void
gdk_gl_context_get_required_version (GdkGLContext *context,
int *major,
int *minor)
{
GdkGLContextPrivate *priv = gdk_gl_context_get_instance_private (context);
gl: Clean up the required version accessors We can simplify the code, since we only have core GL profiles in GDK. https://bugzilla.gnome.org/show_bug.cgi?id=741946
2015-02-09 16:10:22 +00:00
g_return_if_fail (GDK_IS_GL_CONTEXT (context));
glcontext: Simplify get_required_version api Simplify the API to just return the requirements that the user has asked for. The rest of the code was undocumented and previously used as a buggy source for a default value from internal code. Since the buggy code is now fixed, remove all unnecessary cruft.
2022-05-30 18:18:15 +00:00
if (major != NULL)
gdk: Introduce GdkGLVersion ... and use it. Makes the code simpler.
2023-04-25 17:17:07 +00:00
*major = gdk_gl_version_get_major (&priv->required);
glcontext: Simplify get_required_version api Simplify the API to just return the requirements that the user has asked for. The rest of the code was undocumented and previously used as a buggy source for a default value from internal code. Since the buggy code is now fixed, remove all unnecessary cruft.
2022-05-30 18:18:15 +00:00
if (minor != NULL)
gdk: Introduce GdkGLVersion ... and use it. Makes the code simpler.
2023-04-25 17:17:07 +00:00
*minor = gdk_gl_version_get_minor (&priv->required);
glcontext: Simplify get_required_version api Simplify the API to just return the requirements that the user has asked for. The rest of the code was undocumented and previously used as a buggy source for a default value from internal code. Since the buggy code is now fixed, remove all unnecessary cruft.
2022-05-30 18:18:15 +00:00
}
GDK: Force GLES 3.0+ on libANGLE ...when libANGLE is being used on Windows, by checking for a Windows-specific an ANGLE-specific extension.
2022-01-18 16:16:11 +00:00
gdk: Allow querying if a GL context is in legacy mode We want to have the ability to fall back to legacy GL contexts when creating them. In order to do so, we need to store the legacy bit on the GdkGLContext, as well as being able to query it. Setting the legacy bit from outside GDK is not possible; we cannot create GL contexts in 3.2 core profile *and* compatibility modes at the same time, and if we allowed users to select the legacy mode themselves, it would break the creation of the GdkWindow's paint GL context. What we do allow is falling back to legacy GL context if the platform does not support 3.2 core profiles — for instance, on older GPUs or inside virtualized environments. We are also going to use the legacy bit internally, to choose which GL API we can use when drawing GL content. https://bugzilla.gnome.org/show_bug.cgi?id=756142
2015-10-06 17:54:58 +00:00
/**
* gdk_gl_context_is_legacy:
docs: Rework the gdk docs Convert links, make things more concise.
2021-02-21 05:13:57 +00:00
* @context: a `GdkGLContext`
gdk: Allow querying if a GL context is in legacy mode We want to have the ability to fall back to legacy GL contexts when creating them. In order to do so, we need to store the legacy bit on the GdkGLContext, as well as being able to query it. Setting the legacy bit from outside GDK is not possible; we cannot create GL contexts in 3.2 core profile *and* compatibility modes at the same time, and if we allowed users to select the legacy mode themselves, it would break the creation of the GdkWindow's paint GL context. What we do allow is falling back to legacy GL context if the platform does not support 3.2 core profiles — for instance, on older GPUs or inside virtualized environments. We are also going to use the legacy bit internally, to choose which GL API we can use when drawing GL content. https://bugzilla.gnome.org/show_bug.cgi?id=756142
2015-10-06 17:54:58 +00:00
*
docs: Rework the gdk docs Convert links, make things more concise.
2021-02-21 05:13:57 +00:00
* Whether the `GdkGLContext` is in legacy mode or not.
gdk: Allow querying if a GL context is in legacy mode We want to have the ability to fall back to legacy GL contexts when creating them. In order to do so, we need to store the legacy bit on the GdkGLContext, as well as being able to query it. Setting the legacy bit from outside GDK is not possible; we cannot create GL contexts in 3.2 core profile *and* compatibility modes at the same time, and if we allowed users to select the legacy mode themselves, it would break the creation of the GdkWindow's paint GL context. What we do allow is falling back to legacy GL context if the platform does not support 3.2 core profiles — for instance, on older GPUs or inside virtualized environments. We are also going to use the legacy bit internally, to choose which GL API we can use when drawing GL content. https://bugzilla.gnome.org/show_bug.cgi?id=756142
2015-10-06 17:54:58 +00:00
*
docs: Rework the gdk docs Convert links, make things more concise.
2021-02-21 05:13:57 +00:00
* The `GdkGLContext` must be realized before calling this function.
docs: Improve description of gdk_gl_context_is_legacy() Explain why this function is available, and why you may need it. https://bugzilla.gnome.org/show_bug.cgi?id=756142
2015-10-07 07:50:23 +00:00
*
* When realizing a GL context, GDK will try to use the OpenGL 3.2 core
* profile; this profile removes all the OpenGL API that was deprecated
* prior to the 3.2 version of the specification. If the realization is
* successful, this function will return %FALSE.
*
* If the underlying OpenGL implementation does not support core profiles,
* GDK will fall back to a pre-3.2 compatibility profile, and this function
* will return %TRUE.
*
* You can use the value returned by this function to decide which kind
* of OpenGL API to use, or whether to do extension discovery, or what
* kind of shader programs to load.
gdk: Allow querying if a GL context is in legacy mode We want to have the ability to fall back to legacy GL contexts when creating them. In order to do so, we need to store the legacy bit on the GdkGLContext, as well as being able to query it. Setting the legacy bit from outside GDK is not possible; we cannot create GL contexts in 3.2 core profile *and* compatibility modes at the same time, and if we allowed users to select the legacy mode themselves, it would break the creation of the GdkWindow's paint GL context. What we do allow is falling back to legacy GL context if the platform does not support 3.2 core profiles — for instance, on older GPUs or inside virtualized environments. We are also going to use the legacy bit internally, to choose which GL API we can use when drawing GL content. https://bugzilla.gnome.org/show_bug.cgi?id=756142
2015-10-06 17:54:58 +00:00
*
* Returns: %TRUE if the GL context is in legacy mode
*/
gboolean
gdk_gl_context_is_legacy (GdkGLContext *context)
{
GdkGLContextPrivate *priv = gdk_gl_context_get_instance_private (context);
g_return_val_if_fail (GDK_IS_GL_CONTEXT (context), FALSE);
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_return_val_if_fail (gdk_gl_context_is_realized (context), FALSE);
gdk: Allow querying if a GL context is in legacy mode We want to have the ability to fall back to legacy GL contexts when creating them. In order to do so, we need to store the legacy bit on the GdkGLContext, as well as being able to query it. Setting the legacy bit from outside GDK is not possible; we cannot create GL contexts in 3.2 core profile *and* compatibility modes at the same time, and if we allowed users to select the legacy mode themselves, it would break the creation of the GdkWindow's paint GL context. What we do allow is falling back to legacy GL context if the platform does not support 3.2 core profiles — for instance, on older GPUs or inside virtualized environments. We are also going to use the legacy bit internally, to choose which GL API we can use when drawing GL content. https://bugzilla.gnome.org/show_bug.cgi?id=756142
2015-10-06 17:54:58 +00:00
return priv->is_legacy;
}
egl: Make sure highest possible GL version is created The EGL spec states: The context returned must be the specified version, or a later version which is backwards compatible with that version. Even if a later version is returned, the specified version must correspond to a defined version of the client API. GTK has so far been relying on EGL implementations returning a later version, because that is what Mesa does. But ANGLE does not do that and only provides the minimum version, which means Windows EGL has been forced to use a lower EGL version for no reason. So fix this and try versions in order from highest to lowest.
2023-04-25 18:08:33 +00:00
void
gdk_gl_context_set_version (GdkGLContext *context,
const GdkGLVersion *version)
{
GdkGLContextPrivate *priv = gdk_gl_context_get_instance_private (context);
priv->gl_version = *version;
}
gdk: Allow querying if a GL context is in legacy mode We want to have the ability to fall back to legacy GL contexts when creating them. In order to do so, we need to store the legacy bit on the GdkGLContext, as well as being able to query it. Setting the legacy bit from outside GDK is not possible; we cannot create GL contexts in 3.2 core profile *and* compatibility modes at the same time, and if we allowed users to select the legacy mode themselves, it would break the creation of the GdkWindow's paint GL context. What we do allow is falling back to legacy GL context if the platform does not support 3.2 core profiles — for instance, on older GPUs or inside virtualized environments. We are also going to use the legacy bit internally, to choose which GL API we can use when drawing GL content. https://bugzilla.gnome.org/show_bug.cgi?id=756142
2015-10-06 17:54:58 +00:00
void
gdk_gl_context_set_is_legacy (GdkGLContext *context,
gboolean is_legacy)
{
GdkGLContextPrivate *priv = gdk_gl_context_get_instance_private (context);
priv->is_legacy = !!is_legacy;
}
gdk: Add gdk_gl_context_is_shared() ... and use it in the GL renderers.
2021-06-30 02:52:35 +00:00
/**
* gdk_gl_context_is_shared:
* @self: a `GdkGLContext`
* @other: the `GdkGLContext` that should be compatible with @self
*
* Checks if the two GL contexts can share resources.
*
* When they can, the texture IDs from @other can be used in @self. This
* is particularly useful when passing `GdkGLTexture` objects between
* different contexts.
*
* Contexts created for the same display with the same properties will
* always be compatible, even if they are created for different surfaces.
* For other contexts it depends on the GL backend.
*
* Both contexts must be realized for this check to succeed. If either one
* is not, this function will return %FALSE.
*
* Returns: %TRUE if the two GL contexts are compatible.
gdk: add missing Since annotation Signed-off-by: Marc-André Lureau <marcandre.lureau@redhat.com>
2021-07-27 17:01:31 +00:00
*
* Since: 4.4
gdk: Add gdk_gl_context_is_shared() ... and use it in the GL renderers.
2021-06-30 02:52:35 +00:00
*/
gboolean
gdk_gl_context_is_shared (GdkGLContext *self,
GdkGLContext *other)
{
g_return_val_if_fail (GDK_IS_GL_CONTEXT (self), FALSE);
g_return_val_if_fail (GDK_IS_GL_CONTEXT (other), FALSE);
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_realized (self) ||
!gdk_gl_context_is_realized (other))
gdk: Add gdk_gl_context_is_shared() ... and use it in the GL renderers.
2021-06-30 02:52:35 +00:00
return FALSE;
return GDK_GL_CONTEXT_GET_CLASS (self)->is_shared (self, other);
}
glcontext: Add GdkGLContext::allowed-apis This allows specifying the GL APIs in a more comprehensive way than gdk_gl_context_set_use_es().
2021-10-07 15:59:17 +00:00
/**
* gdk_gl_context_set_allowed_apis: (attributes org.gtk.Method.set_property=allowed-apis)
* @self: a GL context
* @apis: the allowed APIs
*
* Sets the allowed APIs. When gdk_gl_context_realize() is called, only the
* allowed APIs will be tried. If you set this to 0, realizing will always fail.
*
* If you set it on a realized context, the property will not have any effect.
* It is only relevant during gdk_gl_context_realize().
*
* By default, all APIs are allowed.
*
* Since: 4.6
**/
void
gdk_gl_context_set_allowed_apis (GdkGLContext *self,
GdkGLAPI apis)
{
GdkGLContextPrivate *priv = gdk_gl_context_get_instance_private (self);
g_return_if_fail (GDK_IS_GL_CONTEXT (self));
if (priv->allowed_apis == apis)
return;
priv->allowed_apis = apis;
g_object_notify_by_pspec (G_OBJECT (self), properties[PROP_ALLOWED_APIS]);
}
/**
* gdk_gl_context_get_allowed_apis: (attributes org.gtk.Method.get_property=allowed-apis)
* @self: a GL context
*
* Gets the allowed APIs set via gdk_gl_context_set_allowed_apis().
*
* Returns: the allowed APIs
*
* Since: 4.6
**/
GdkGLAPI
gdk_gl_context_get_allowed_apis (GdkGLContext *self)
{
GdkGLContextPrivate *priv = gdk_gl_context_get_instance_private (self);
g_return_val_if_fail (GDK_IS_GL_CONTEXT (self), 0);
return priv->allowed_apis;
}
glcontext: Add gdk_gl_context_get_api() This is mostly for inspector. Not sure if we also want to deprecate gdk_gl_context_get_use_es() in favor of this function.
2021-10-07 21:03:45 +00:00
/**
* gdk_gl_context_get_api: (attributes org.gtk.Method.get_property=api)
* @self: a GL context
*
* Gets the API currently in use.
*
* If the renderer has not been realized yet, 0 is returned.
*
* Returns: the currently used API
*
* Since: 4.6
**/
GdkGLAPI
gdk_gl_context_get_api (GdkGLContext *self)
{
GdkGLContextPrivate *priv = gdk_gl_context_get_instance_private (self);
g_return_val_if_fail (GDK_IS_GL_CONTEXT (self), 0);
return priv->api;
}
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
gdk_gl_context_is_api_allowed (GdkGLContext *self,
GdkGLAPI api,
GError **error)
{
GdkGLContextPrivate *priv = gdk_gl_context_get_instance_private (self);
gl: Tweak debug values for GL api selection Replace GDK_DEBUG=gl-gles with GDK_DEBUG=gl-disable-gl, and add a GDK_DEBUG=gl-disable-gles to match.
2023-11-18 13:55:34 +00:00
GdkDebugFlags flags;
GdkGLAPI allowed_apis;
allowed_apis = priv->allowed_apis;
flags = gdk_display_get_debug_flags (gdk_gl_context_get_display (self));
if (flags & GDK_DEBUG_GL_DISABLE_GLES)
{
if (api == GDK_GL_API_GLES)
{
g_set_error_literal (error, GDK_GL_ERROR, GDK_GL_ERROR_NOT_AVAILABLE,
_("OpenGL ES disabled via GDK_DEBUG"));
return FALSE;
}
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
gl: Tweak debug values for GL api selection Replace GDK_DEBUG=gl-gles with GDK_DEBUG=gl-disable-gl, and add a GDK_DEBUG=gl-disable-gles to match.
2023-11-18 13:55:34 +00:00
allowed_apis &= ~GDK_GL_API_GLES;
}
if (flags & GDK_DEBUG_GL_DISABLE_GL)
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
{
gl: Tweak debug values for GL api selection Replace GDK_DEBUG=gl-gles with GDK_DEBUG=gl-disable-gl, and add a GDK_DEBUG=gl-disable-gles to match.
2023-11-18 13:55:34 +00:00
if (api == GDK_GL_API_GL)
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_set_error_literal (error, GDK_GL_ERROR, GDK_GL_ERROR_NOT_AVAILABLE,
gl: Tweak debug values for GL api selection Replace GDK_DEBUG=gl-gles with GDK_DEBUG=gl-disable-gl, and add a GDK_DEBUG=gl-disable-gles to match.
2023-11-18 13:55:34 +00:00
_("OpenGL disabled via GDK_DEBUG"));
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 FALSE;
}
gl: Tweak debug values for GL api selection Replace GDK_DEBUG=gl-gles with GDK_DEBUG=gl-disable-gl, and add a GDK_DEBUG=gl-disable-gles to match.
2023-11-18 13:55:34 +00:00
allowed_apis &= ~GDK_GL_API_GL;
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
}
gl: Tweak debug values for GL api selection Replace GDK_DEBUG=gl-gles with GDK_DEBUG=gl-disable-gl, and add a GDK_DEBUG=gl-disable-gles to match.
2023-11-18 13:55:34 +00:00
if (allowed_apis & api)
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 TRUE;
g_set_error (error, GDK_GL_ERROR, GDK_GL_ERROR_NOT_AVAILABLE,
_("Application does not support %s API"),
api == GDK_GL_API_GL ? "OpenGL" : "OpenGL ES");
return FALSE;
}
gl: Add more OpenGL ES checks Check for the appropriate extensions depending on which type of API we're using.
2016-04-22 16:27:04 +00:00
/**
* gdk_gl_context_set_use_es:
docs: Rework the gdk docs Convert links, make things more concise.
2021-02-21 05:13:57 +00:00
* @context: a `GdkGLContext`
gdk/gl: Allow autodetection for GL/GLES If the GdkGLContext was not explicitly instructed to use or not GLES, we can detect whether the underlying API is going to be desktop GL or GLES. https://bugzilla.gnome.org/show_bug.cgi?id=773180
2016-10-19 12:43:17 +00:00
* @use_es: whether the context should use OpenGL ES instead of OpenGL,
* or -1 to allow auto-detection
gl: Add more OpenGL ES checks Check for the appropriate extensions depending on which type of API we're using.
2016-04-22 16:27:04 +00:00
*
docs: Rework the gdk docs Convert links, make things more concise.
2021-02-21 05:13:57 +00:00
* Requests that GDK create an OpenGL ES context instead of an OpenGL one.
*
* Not all platforms support OpenGL ES.
gl: Add more OpenGL ES checks Check for the appropriate extensions depending on which type of API we're using.
2016-04-22 16:27:04 +00:00
*
* The @context must not have been realized.
*
gdk/gl: Allow autodetection for GL/GLES If the GdkGLContext was not explicitly instructed to use or not GLES, we can detect whether the underlying API is going to be desktop GL or GLES. https://bugzilla.gnome.org/show_bug.cgi?id=773180
2016-10-19 12:43:17 +00:00
* By default, GDK will attempt to automatically detect whether the
* underlying GL implementation is OpenGL or OpenGL ES once the @context
* is realized.
*
docs: Rework the gdk docs Convert links, make things more concise.
2021-02-21 05:13:57 +00:00
* You should check the return value of [method@Gdk.GLContext.get_use_es]
* after calling [method@Gdk.GLContext.realize] to decide whether to use
* the OpenGL or OpenGL ES API, extensions, or shaders.
gl: Add more OpenGL ES checks Check for the appropriate extensions depending on which type of API we're using.
2016-04-22 16:27:04 +00:00
*/
gl: Add 'use-es' flag On some platforms we can ask the GL context machinery to create a GLES context, instead of a GL one. In order to ask for a GLES context at GdkGLContext realization time, we use a bit field like we do for forward compatible, or debug contexts. The 'use-es' bit also changes the way we select a default version, because OpenGL and OpenGLES versions differ. https://bugzilla.gnome.org/show_bug.cgi?id=743746
2016-04-18 09:10:30 +00:00
void
gdk_gl_context_set_use_es (GdkGLContext *context,
gdk/gl: Allow autodetection for GL/GLES If the GdkGLContext was not explicitly instructed to use or not GLES, we can detect whether the underlying API is going to be desktop GL or GLES. https://bugzilla.gnome.org/show_bug.cgi?id=773180
2016-10-19 12:43:17 +00:00
int use_es)
gl: Add 'use-es' flag On some platforms we can ask the GL context machinery to create a GLES context, instead of a GL one. In order to ask for a GLES context at GdkGLContext realization time, we use a bit field like we do for forward compatible, or debug contexts. The 'use-es' bit also changes the way we select a default version, because OpenGL and OpenGLES versions differ. https://bugzilla.gnome.org/show_bug.cgi?id=743746
2016-04-18 09:10:30 +00:00
{
gl: Add more OpenGL ES checks Check for the appropriate extensions depending on which type of API we're using.
2016-04-22 16:27:04 +00:00
g_return_if_fail (GDK_IS_GL_CONTEXT (context));
glcontext: Reinstate missing "!" Replacing the return_if_fail()s in commit f584d4f50025 lost the inversions. Fixes #4349
2021-10-16 13:47:05 +00:00
g_return_if_fail (!gdk_gl_context_is_realized (context));
gl: Add more OpenGL ES checks Check for the appropriate extensions depending on which type of API we're using.
2016-04-22 16:27:04 +00:00
glcontext: Deprecate gdk_gl_context_set_use_es() Make it call gdk_gl_context_set_allowed_apis(). Also port callers to use this function.
2021-10-07 16:13:36 +00:00
switch (use_es)
{
case -1:
gdk_gl_context_set_allowed_apis (context, DEFAULT_ALLOWED_APIS);
break;
case 0:
gdk_gl_context_set_allowed_apis (context, GDK_GL_API_GL);
break;
case 1:
gdk_gl_context_set_allowed_apis (context, GDK_GL_API_GLES);
break;
default:
/* Just ignore the call */
break;
}
gl: Add 'use-es' flag On some platforms we can ask the GL context machinery to create a GLES context, instead of a GL one. In order to ask for a GLES context at GdkGLContext realization time, we use a bit field like we do for forward compatible, or debug contexts. The 'use-es' bit also changes the way we select a default version, because OpenGL and OpenGLES versions differ. https://bugzilla.gnome.org/show_bug.cgi?id=743746
2016-04-18 09:10:30 +00:00
}
gl: Add more OpenGL ES checks Check for the appropriate extensions depending on which type of API we're using.
2016-04-22 16:27:04 +00:00
/**
* gdk_gl_context_get_use_es:
docs: Rework the gdk docs Convert links, make things more concise.
2021-02-21 05:13:57 +00:00
* @context: a `GdkGLContext`
gl: Add more OpenGL ES checks Check for the appropriate extensions depending on which type of API we're using.
2016-04-22 16:27:04 +00:00
*
* Checks whether the @context is using an OpenGL or OpenGL ES profile.
*
glcontext: Improve documentation on get_use_es api
2022-05-30 18:47:40 +00:00
* Returns: %TRUE if the `GdkGLContext` is using an OpenGL ES profile;
* %FALSE if other profile is in use of if the @context has not yet
* been realized.
gl: Add more OpenGL ES checks Check for the appropriate extensions depending on which type of API we're using.
2016-04-22 16:27:04 +00:00
*/
gl: Add 'use-es' flag On some platforms we can ask the GL context machinery to create a GLES context, instead of a GL one. In order to ask for a GLES context at GdkGLContext realization time, we use a bit field like we do for forward compatible, or debug contexts. The 'use-es' bit also changes the way we select a default version, because OpenGL and OpenGLES versions differ. https://bugzilla.gnome.org/show_bug.cgi?id=743746
2016-04-18 09:10:30 +00:00
gboolean
gdk_gl_context_get_use_es (GdkGLContext *context)
{
GdkGLContextPrivate *priv = gdk_gl_context_get_instance_private (context);
gl: Add more OpenGL ES checks Check for the appropriate extensions depending on which type of API we're using.
2016-04-22 16:27:04 +00:00
g_return_val_if_fail (GDK_IS_GL_CONTEXT (context), FALSE);
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 priv->api == GDK_GL_API_GLES;
gl: Add 'use-es' flag On some platforms we can ask the GL context machinery to create a GLES context, instead of a GL one. In order to ask for a GLES context at GdkGLContext realization time, we use a bit field like we do for forward compatible, or debug contexts. The 'use-es' bit also changes the way we select a default version, because OpenGL and OpenGLES versions differ. https://bugzilla.gnome.org/show_bug.cgi?id=743746
2016-04-18 09:10:30 +00:00
}
gdkglcontext: Fix build with MSVC GLDEBUGPROC callback is defined with APIENTRY which is a windows specific calling convention. That macro expands to nothing when building on other platforms. Fixes: #3268.
2020-10-18 21:14:22 +00:00
static void APIENTRY
GdkGLContext: Add a GL debug message callback If G_ENABLE_CONSISTENCY_CHECKS is defined (i.e. if our buildtype is 'debug'), add a opengl debug callback that prints all debug messages with a severity higher than SEVERITY_NOTIFICATION as a warning to the console.
2018-03-25 13:28:40 +00:00
gl_debug_message_callback (GLenum source,
GLenum type,
GLuint id,
GLenum severity,
GLsizei length,
const GLchar *message,
const void *user_data)
{
const char *message_source;
const char *message_type;
const char *message_severity;
glcontext: Use different log levels for GL debug We want critical GL debug messages to be critical, so that the testsuite sudokus itself when they appear. This is relevant in particular for GLES warnings in the GLES runner, because its warnings can cause crashes on GL drivers less forgiving than Mesa. Related: #4571
2021-12-25 13:41:20 +00:00
GLogLevelFlags log_level;
GdkGLContext: Add a GL debug message callback If G_ENABLE_CONSISTENCY_CHECKS is defined (i.e. if our buildtype is 'debug'), add a opengl debug callback that prints all debug messages with a severity higher than SEVERITY_NOTIFICATION as a warning to the console.
2018-03-25 13:28:40 +00:00
if (severity == GL_DEBUG_SEVERITY_NOTIFICATION)
return;
switch (source)
{
case GL_DEBUG_SOURCE_API:
message_source = "API";
break;
case GL_DEBUG_SOURCE_WINDOW_SYSTEM:
message_source = "Window System";
break;
case GL_DEBUG_SOURCE_SHADER_COMPILER:
message_source = "Shader Compiler";
break;
case GL_DEBUG_SOURCE_THIRD_PARTY:
message_source = "Third Party";
break;
case GL_DEBUG_SOURCE_APPLICATION:
message_source = "Application";
break;
case GL_DEBUG_SOURCE_OTHER:
default:
message_source = "Other";
}
switch (type)
{
case GL_DEBUG_TYPE_ERROR:
message_type = "Error";
break;
case GL_DEBUG_TYPE_DEPRECATED_BEHAVIOR:
message_type = "Deprecated Behavior";
break;
case GL_DEBUG_TYPE_UNDEFINED_BEHAVIOR:
message_type = "Undefined Behavior";
break;
case GL_DEBUG_TYPE_PORTABILITY:
message_type = "Portability";
break;
case GL_DEBUG_TYPE_PERFORMANCE:
message_type = "Performance";
break;
case GL_DEBUG_TYPE_MARKER:
message_type = "Marker";
break;
case GL_DEBUG_TYPE_PUSH_GROUP:
message_type = "Push Group";
break;
case GL_DEBUG_TYPE_POP_GROUP:
message_type = "Pop Group";
break;
case GL_DEBUG_TYPE_OTHER:
default:
message_type = "Other";
}
switch (severity)
{
case GL_DEBUG_SEVERITY_HIGH:
message_severity = "High";
glcontext: Use different log levels for GL debug We want critical GL debug messages to be critical, so that the testsuite sudokus itself when they appear. This is relevant in particular for GLES warnings in the GLES runner, because its warnings can cause crashes on GL drivers less forgiving than Mesa. Related: #4571
2021-12-25 13:41:20 +00:00
log_level = G_LOG_LEVEL_CRITICAL;
GdkGLContext: Add a GL debug message callback If G_ENABLE_CONSISTENCY_CHECKS is defined (i.e. if our buildtype is 'debug'), add a opengl debug callback that prints all debug messages with a severity higher than SEVERITY_NOTIFICATION as a warning to the console.
2018-03-25 13:28:40 +00:00
break;
case GL_DEBUG_SEVERITY_MEDIUM:
message_severity = "Medium";
glcontext: Use different log levels for GL debug We want critical GL debug messages to be critical, so that the testsuite sudokus itself when they appear. This is relevant in particular for GLES warnings in the GLES runner, because its warnings can cause crashes on GL drivers less forgiving than Mesa. Related: #4571
2021-12-25 13:41:20 +00:00
log_level = G_LOG_LEVEL_WARNING;
GdkGLContext: Add a GL debug message callback If G_ENABLE_CONSISTENCY_CHECKS is defined (i.e. if our buildtype is 'debug'), add a opengl debug callback that prints all debug messages with a severity higher than SEVERITY_NOTIFICATION as a warning to the console.
2018-03-25 13:28:40 +00:00
break;
case GL_DEBUG_SEVERITY_LOW:
message_severity = "Low";
glcontext: Use different log levels for GL debug We want critical GL debug messages to be critical, so that the testsuite sudokus itself when they appear. This is relevant in particular for GLES warnings in the GLES runner, because its warnings can cause crashes on GL drivers less forgiving than Mesa. Related: #4571
2021-12-25 13:41:20 +00:00
log_level = G_LOG_LEVEL_MESSAGE;
GdkGLContext: Add a GL debug message callback If G_ENABLE_CONSISTENCY_CHECKS is defined (i.e. if our buildtype is 'debug'), add a opengl debug callback that prints all debug messages with a severity higher than SEVERITY_NOTIFICATION as a warning to the console.
2018-03-25 13:28:40 +00:00
break;
case GL_DEBUG_SEVERITY_NOTIFICATION:
message_severity = "Notification";
glcontext: Use different log levels for GL debug We want critical GL debug messages to be critical, so that the testsuite sudokus itself when they appear. This is relevant in particular for GLES warnings in the GLES runner, because its warnings can cause crashes on GL drivers less forgiving than Mesa. Related: #4571
2021-12-25 13:41:20 +00:00
log_level = G_LOG_LEVEL_INFO;
GdkGLContext: Add a GL debug message callback If G_ENABLE_CONSISTENCY_CHECKS is defined (i.e. if our buildtype is 'debug'), add a opengl debug callback that prints all debug messages with a severity higher than SEVERITY_NOTIFICATION as a warning to the console.
2018-03-25 13:28:40 +00:00
break;
default:
message_severity = "Unknown";
glcontext: Use different log levels for GL debug We want critical GL debug messages to be critical, so that the testsuite sudokus itself when they appear. This is relevant in particular for GLES warnings in the GLES runner, because its warnings can cause crashes on GL drivers less forgiving than Mesa. Related: #4571
2021-12-25 13:41:20 +00:00
log_level = G_LOG_LEVEL_MESSAGE;
GdkGLContext: Add a GL debug message callback If G_ENABLE_CONSISTENCY_CHECKS is defined (i.e. if our buildtype is 'debug'), add a opengl debug callback that prints all debug messages with a severity higher than SEVERITY_NOTIFICATION as a warning to the console.
2018-03-25 13:28:40 +00:00
}
glcontext: Use different log levels for GL debug We want critical GL debug messages to be critical, so that the testsuite sudokus itself when they appear. This is relevant in particular for GLES warnings in the GLES runner, because its warnings can cause crashes on GL drivers less forgiving than Mesa. Related: #4571
2021-12-25 13:41:20 +00:00
/* There's no higher level function taking a log level argument... */
g_log_structured_standard (G_LOG_DOMAIN, log_level,
__FILE__, G_STRINGIFY (__LINE__),
G_STRFUNC,
"OPENGL:\n Source: %s\n Type: %s\n Severity: %s\n Message: %s",
message_source, message_type, message_severity, message);
GdkGLContext: Add a GL debug message callback If G_ENABLE_CONSISTENCY_CHECKS is defined (i.e. if our buildtype is 'debug'), add a opengl debug callback that prints all debug messages with a severity higher than SEVERITY_NOTIFICATION as a warning to the console.
2018-03-25 13:28:40 +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
/**
* gdk_gl_context_realize:
docs: Rework the gdk docs Convert links, make things more concise.
2021-02-21 05:13:57 +00:00
* @context: a `GdkGLContext`
* @error: return location for a `GError`
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
*
docs: Rework the gdk docs Convert links, make things more concise.
2021-02-21 05:13:57 +00:00
* Realizes the given `GdkGLContext`.
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
*
docs: Rework the gdk docs Convert links, make things more concise.
2021-02-21 05:13:57 +00:00
* It is safe to call this function on a realized `GdkGLContext`.
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
*
* Returns: %TRUE if the context is realized
*/
gboolean
gdk_gl_context_realize (GdkGLContext *context,
GError **error)
{
GdkGLContextPrivate *priv = gdk_gl_context_get_instance_private (context);
g_return_val_if_fail (GDK_IS_GL_CONTEXT (context), FALSE);
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 (priv->api)
gl: Clean up the required version accessors We can simplify the code, since we only have core GL profiles in GDK. https://bugzilla.gnome.org/show_bug.cgi?id=741946
2015-02-09 16:10:22 +00:00
return TRUE;
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
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
priv->api = GDK_GL_CONTEXT_GET_CLASS (context)->realize (context, error);
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
glcontext: Add gdk_gl_context_get_api() This is mostly for inspector. Not sure if we also want to deprecate gdk_gl_context_get_use_es() in favor of this function.
2021-10-07 21:03:45 +00:00
if (priv->api)
glcontext: assert all contexts set the version on realize() Now that all contexts do that, insist that they keep doing it. And because they keep doing it, we can support querying the GL version from gdk_gl_context_get_version() without requiring the context to be made current.
2023-04-25 20:45:34 +00:00
{
g_assert (gdk_gl_version_greater_equal (&priv->gl_version, &GDK_GL_VERSION_INIT (0, 0)));
g_object_notify_by_pspec (G_OBJECT (context), properties[PROP_API]);
}
glcontext: Add gdk_gl_context_get_api() This is mostly for inspector. Not sure if we also want to deprecate gdk_gl_context_get_use_es() in favor of this function.
2021-10-07 21:03:45 +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
return priv->api;
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
}
glcontext: Add gdk_gl_context_get_memory_flags() Checks which features of a given memory format are supported by the current GL implementation. We check: * usable: Can be used as a texture with NEAREST filter * renderable: Can be used as a render target * filterable: Can be used with GL_LINEAR In normal GL, all formats are all of these things, but GLES is a lot more picky. So far nobody uses this.
2023-12-07 04:45:59 +00:00
static void
gdk_gl_context_init_memory_flags (GdkGLContext *self)
{
GdkGLContextPrivate *priv = gdk_gl_context_get_instance_private (self);
gsize i;
if (!gdk_gl_context_get_use_es (self))
{
for (i = 0; i < G_N_ELEMENTS (priv->memory_flags); i++)
{
priv->memory_flags[i] = GDK_GL_FORMAT_USABLE | GDK_GL_FORMAT_RENDERABLE | GDK_GL_FORMAT_FILTERABLE;
}
return;
}
/* GLES 2.0 spec, tables 3.2 and 3.3 */
priv->memory_flags[GDK_MEMORY_R8G8B8] = GDK_GL_FORMAT_USABLE | GDK_GL_FORMAT_FILTERABLE;
priv->memory_flags[GDK_MEMORY_R8G8B8A8_PREMULTIPLIED] = GDK_GL_FORMAT_USABLE | GDK_GL_FORMAT_FILTERABLE;
priv->memory_flags[GDK_MEMORY_R8G8B8A8] = GDK_GL_FORMAT_USABLE | GDK_GL_FORMAT_FILTERABLE;
#if 0
/* GLES2 can do these, but GTK can't */
priv->memory_flags[GDK_MEMORY_A8] = GDK_GL_FORMAT_USABLE | GDK_GL_FORMAT_FILTERABLE;
priv->memory_flags[GDK_MEMORY_G8] = GDK_GL_FORMAT_USABLE | GDK_GL_FORMAT_FILTERABLE;
priv->memory_flags[GDK_MEMORY_G8A8_PREMULTIPLIED] = GDK_GL_FORMAT_USABLE | GDK_GL_FORMAT_FILTERABLE;
priv->memory_flags[GDK_MEMORY_G8A8] = GDK_GL_FORMAT_USABLE | GDK_GL_FORMAT_FILTERABLE;
#endif
if (gdk_gl_version_greater_equal (&priv->gl_version, &GDK_GL_VERSION_INIT (3, 0)))
{
/* GLES 3.0.6 spec, table 3.13 */
priv->memory_flags[GDK_MEMORY_G8] |= GDK_GL_FORMAT_USABLE | GDK_GL_FORMAT_RENDERABLE | GDK_GL_FORMAT_FILTERABLE;
priv->memory_flags[GDK_MEMORY_A8] |= GDK_GL_FORMAT_USABLE | GDK_GL_FORMAT_RENDERABLE | GDK_GL_FORMAT_FILTERABLE;
priv->memory_flags[GDK_MEMORY_G8A8_PREMULTIPLIED] |= GDK_GL_FORMAT_USABLE | GDK_GL_FORMAT_RENDERABLE | GDK_GL_FORMAT_FILTERABLE;
priv->memory_flags[GDK_MEMORY_G8A8] |= GDK_GL_FORMAT_USABLE | GDK_GL_FORMAT_RENDERABLE | GDK_GL_FORMAT_FILTERABLE;
priv->memory_flags[GDK_MEMORY_R8G8B8] |= GDK_GL_FORMAT_USABLE | GDK_GL_FORMAT_RENDERABLE | GDK_GL_FORMAT_FILTERABLE;
priv->memory_flags[GDK_MEMORY_R8G8B8A8_PREMULTIPLIED] |= GDK_GL_FORMAT_USABLE | GDK_GL_FORMAT_RENDERABLE | GDK_GL_FORMAT_FILTERABLE;
priv->memory_flags[GDK_MEMORY_R8G8B8A8] |= GDK_GL_FORMAT_USABLE | GDK_GL_FORMAT_RENDERABLE | GDK_GL_FORMAT_FILTERABLE;
priv->memory_flags[GDK_MEMORY_R8G8B8X8] |= GDK_GL_FORMAT_USABLE | GDK_GL_FORMAT_RENDERABLE | GDK_GL_FORMAT_FILTERABLE;
glcontext: Fix a mixup of flags I swapped RENDERABLE and FILTERABLE when building this table.
2024-01-03 09:15:33 +00:00
priv->memory_flags[GDK_MEMORY_R16G16B16_FLOAT] |= GDK_GL_FORMAT_USABLE | GDK_GL_FORMAT_FILTERABLE;
priv->memory_flags[GDK_MEMORY_R16G16B16A16_FLOAT_PREMULTIPLIED] |= GDK_GL_FORMAT_USABLE | GDK_GL_FORMAT_FILTERABLE;
priv->memory_flags[GDK_MEMORY_R16G16B16A16_FLOAT] |= GDK_GL_FORMAT_USABLE | GDK_GL_FORMAT_FILTERABLE;
priv->memory_flags[GDK_MEMORY_A16_FLOAT] |= GDK_GL_FORMAT_USABLE | GDK_GL_FORMAT_FILTERABLE;
glcontext: Add gdk_gl_context_get_memory_flags() Checks which features of a given memory format are supported by the current GL implementation. We check: * usable: Can be used as a texture with NEAREST filter * renderable: Can be used as a render target * filterable: Can be used with GL_LINEAR In normal GL, all formats are all of these things, but GLES is a lot more picky. So far nobody uses this.
2023-12-07 04:45:59 +00:00
priv->memory_flags[GDK_MEMORY_R32G32B32_FLOAT] |= GDK_GL_FORMAT_USABLE;
priv->memory_flags[GDK_MEMORY_R32G32B32A32_FLOAT_PREMULTIPLIED] |= GDK_GL_FORMAT_USABLE;
priv->memory_flags[GDK_MEMORY_R32G32B32A32_FLOAT] |= GDK_GL_FORMAT_USABLE;
priv->memory_flags[GDK_MEMORY_A32_FLOAT] |= GDK_GL_FORMAT_USABLE;
/* no changes in GLES 3.1 spec, table 8.13 */
if (gdk_gl_version_greater_equal (&priv->gl_version, &GDK_GL_VERSION_INIT (3, 2)))
{
/* GLES 3.2 spec, table 8.10 */
glcontext: Fix a mixup of flags I swapped RENDERABLE and FILTERABLE when building this table.
2024-01-03 09:15:33 +00:00
priv->memory_flags[GDK_MEMORY_R16G16B16A16_FLOAT_PREMULTIPLIED] |= GDK_GL_FORMAT_RENDERABLE;
priv->memory_flags[GDK_MEMORY_R16G16B16A16_FLOAT] |= GDK_GL_FORMAT_RENDERABLE;
priv->memory_flags[GDK_MEMORY_A16_FLOAT] |= GDK_GL_FORMAT_RENDERABLE;
priv->memory_flags[GDK_MEMORY_R32G32B32A32_FLOAT_PREMULTIPLIED] |= GDK_GL_FORMAT_RENDERABLE;
priv->memory_flags[GDK_MEMORY_R32G32B32A32_FLOAT] |= GDK_GL_FORMAT_RENDERABLE;
priv->memory_flags[GDK_MEMORY_A32_FLOAT] |= GDK_GL_FORMAT_RENDERABLE;
glcontext: Add gdk_gl_context_get_memory_flags() Checks which features of a given memory format are supported by the current GL implementation. We check: * usable: Can be used as a texture with NEAREST filter * renderable: Can be used as a render target * filterable: Can be used with GL_LINEAR In normal GL, all formats are all of these things, but GLES is a lot more picky. So far nobody uses this.
2023-12-07 04:45:59 +00:00
}
}
if (epoxy_has_gl_extension ("GL_OES_rgb8_rgba8"))
{
priv->memory_flags[GDK_MEMORY_R8G8B8A8_PREMULTIPLIED] |= GDK_GL_FORMAT_USABLE | GDK_GL_FORMAT_RENDERABLE | GDK_GL_FORMAT_FILTERABLE;
priv->memory_flags[GDK_MEMORY_R8G8B8A8] |= GDK_GL_FORMAT_USABLE | GDK_GL_FORMAT_RENDERABLE | GDK_GL_FORMAT_FILTERABLE;
priv->memory_flags[GDK_MEMORY_R8G8B8] |= GDK_GL_FORMAT_USABLE | GDK_GL_FORMAT_RENDERABLE | GDK_GL_FORMAT_FILTERABLE;
if (gdk_gl_version_greater_equal (&priv->gl_version, &GDK_GL_VERSION_INIT (3, 0)))
priv->memory_flags[GDK_MEMORY_R8G8B8X8] |= GDK_GL_FORMAT_USABLE | GDK_GL_FORMAT_RENDERABLE | GDK_GL_FORMAT_FILTERABLE;
}
if (epoxy_has_gl_extension ("GL_EXT_abgr"))
{
priv->memory_flags[GDK_MEMORY_A8B8G8R8_PREMULTIPLIED] |= GDK_GL_FORMAT_USABLE | GDK_GL_FORMAT_RENDERABLE | GDK_GL_FORMAT_FILTERABLE;
priv->memory_flags[GDK_MEMORY_A8B8G8R8] |= GDK_GL_FORMAT_USABLE | GDK_GL_FORMAT_RENDERABLE | GDK_GL_FORMAT_FILTERABLE;
if (gdk_gl_version_greater_equal (&priv->gl_version, &GDK_GL_VERSION_INIT (3, 0)))
priv->memory_flags[GDK_MEMORY_X8B8G8R8] |= GDK_GL_FORMAT_USABLE | GDK_GL_FORMAT_RENDERABLE | GDK_GL_FORMAT_FILTERABLE;
}
if (epoxy_has_gl_extension ("GL_EXT_texture_format_BGRA8888"))
{
priv->memory_flags[GDK_MEMORY_B8G8R8A8_PREMULTIPLIED] |= GDK_GL_FORMAT_USABLE | GDK_GL_FORMAT_RENDERABLE | GDK_GL_FORMAT_FILTERABLE;
priv->memory_flags[GDK_MEMORY_B8G8R8A8] |= GDK_GL_FORMAT_USABLE | GDK_GL_FORMAT_RENDERABLE | GDK_GL_FORMAT_FILTERABLE;
if (gdk_gl_version_greater_equal (&priv->gl_version, &GDK_GL_VERSION_INIT (3, 0)))
priv->memory_flags[GDK_MEMORY_B8G8R8X8] |= GDK_GL_FORMAT_USABLE | GDK_GL_FORMAT_RENDERABLE | GDK_GL_FORMAT_FILTERABLE;
}
/* Technically, those extensions are supported on GLES2.
* However, GTK uses the wrong format/type pairs with them, so we don't enable them.
*/
if (gdk_gl_version_greater_equal (&priv->gl_version, &GDK_GL_VERSION_INIT (3, 0)))
{
if (epoxy_has_gl_extension ("GL_EXT_texture_norm16"))
{
priv->memory_flags[GDK_MEMORY_R16G16B16A16_PREMULTIPLIED] |= GDK_GL_FORMAT_USABLE | GDK_GL_FORMAT_RENDERABLE | GDK_GL_FORMAT_FILTERABLE;
priv->memory_flags[GDK_MEMORY_R16G16B16A16] |= GDK_GL_FORMAT_USABLE | GDK_GL_FORMAT_RENDERABLE | GDK_GL_FORMAT_FILTERABLE;
priv->memory_flags[GDK_MEMORY_R16G16B16] |= GDK_GL_FORMAT_USABLE | GDK_GL_FORMAT_FILTERABLE;
priv->memory_flags[GDK_MEMORY_G16A16_PREMULTIPLIED] |= GDK_GL_FORMAT_USABLE | GDK_GL_FORMAT_RENDERABLE | GDK_GL_FORMAT_FILTERABLE;
priv->memory_flags[GDK_MEMORY_G16A16] |= GDK_GL_FORMAT_USABLE | GDK_GL_FORMAT_RENDERABLE | GDK_GL_FORMAT_FILTERABLE;
priv->memory_flags[GDK_MEMORY_G16] |= GDK_GL_FORMAT_USABLE | GDK_GL_FORMAT_RENDERABLE | GDK_GL_FORMAT_FILTERABLE;
priv->memory_flags[GDK_MEMORY_A16] |= GDK_GL_FORMAT_USABLE | GDK_GL_FORMAT_RENDERABLE | GDK_GL_FORMAT_FILTERABLE;
}
if (epoxy_has_gl_extension ("GL_OES_texture_half_float"))
{
GdkGLMemoryFlags flags = GDK_GL_FORMAT_USABLE;
if (epoxy_has_gl_extension ("GL_EXT_color_buffer_half_float"))
flags |= GDK_GL_FORMAT_RENDERABLE;
if (epoxy_has_gl_extension ("GL_OES_texture_half_float_linear"))
flags |= GDK_GL_FORMAT_FILTERABLE;
priv->memory_flags[GDK_MEMORY_R16G16B16A16_FLOAT_PREMULTIPLIED] |= flags;
priv->memory_flags[GDK_MEMORY_R16G16B16A16_FLOAT] |= flags;
glcontext: Mark RGB16F as not renderable According to EXT_color_buffer_half_float it should be renderable, but it fails to glGenerateMipmap() with Mesa 23.3 so just pretend it's not renderable until that is fixed. Fixes CI from failing.
2024-01-03 09:20:15 +00:00
/* disabled for now, see https://gitlab.freedesktop.org/mesa/mesa/-/issues/10378 */
priv->memory_flags[GDK_MEMORY_R16G16B16_FLOAT] |= flags & ~GDK_GL_FORMAT_RENDERABLE;
glcontext: Add gdk_gl_context_get_memory_flags() Checks which features of a given memory format are supported by the current GL implementation. We check: * usable: Can be used as a texture with NEAREST filter * renderable: Can be used as a render target * filterable: Can be used with GL_LINEAR In normal GL, all formats are all of these things, but GLES is a lot more picky. So far nobody uses this.
2023-12-07 04:45:59 +00:00
priv->memory_flags[GDK_MEMORY_A16_FLOAT] |= flags;
}
if (epoxy_has_gl_extension ("GL_OES_texture_float"))
{
GdkGLMemoryFlags flags = GDK_GL_FORMAT_USABLE;
if (epoxy_has_gl_extension ("GL_EXT_color_buffer_float"))
flags |= GDK_GL_FORMAT_RENDERABLE;
if (epoxy_has_gl_extension ("GL_OES_texture_float_linear"))
flags |= GDK_GL_FORMAT_FILTERABLE;
priv->memory_flags[GDK_MEMORY_R32G32B32A32_FLOAT_PREMULTIPLIED] |= flags;
priv->memory_flags[GDK_MEMORY_R32G32B32A32_FLOAT] |= flags;
glcontext: RGB32F is not renderable I naively assumed the EXT_color_buffer_float and EXT_color_buffer_half_float extensions would mirror each other, but they do not. The float extension explicitly excludes RGB32F from the renderable formats.
2024-01-03 09:16:13 +00:00
priv->memory_flags[GDK_MEMORY_R32G32B32_FLOAT] |= flags & ~GDK_GL_FORMAT_RENDERABLE;
glcontext: Add gdk_gl_context_get_memory_flags() Checks which features of a given memory format are supported by the current GL implementation. We check: * usable: Can be used as a texture with NEAREST filter * renderable: Can be used as a render target * filterable: Can be used with GL_LINEAR In normal GL, all formats are all of these things, but GLES is a lot more picky. So far nobody uses this.
2023-12-07 04:45:59 +00:00
priv->memory_flags[GDK_MEMORY_A32_FLOAT] |= flags;
}
}
}
gdk: Introduce GdkGLVersion ... and use it. Makes the code simpler.
2023-04-25 17:17:07 +00:00
void
gdk_gl_version_init_epoxy (GdkGLVersion *version)
{
int epoxy_version = epoxy_gl_version ();
*version = GDK_GL_VERSION_INIT (epoxy_version / 10, epoxy_version % 10);
}
gdkglcontext: Track whether to use GL_TEXTURE_2D or GL_TEXTURE_RECTANGL_ARB
2014-10-27 20:12:40 +00:00
static void
GL: Split GL context creation in two phases One of the major requests by OpenGL users has been the ability to specify settings when creating a GL context, like the version to use or whether the debug support should be enabled. We have a couple of requirements in terms of API: • avoid, if at all possible, the "C arrays of integers with attribute, value pairs", which are hard to write and hard to bind in non-C languages. • allow failing in a recoverable way. • do not make the GL context creation API a mess of arguments. Looking at prior art, it seems that a common pattern is to split the construction phase in two: • a first phase that creates a GL context wrapper object and does preliminary checks on the environment. • a second phase that creates the backend-specific GL object. We adopted a similar pattern: • gdk_window_create_gl_context() creates a GdkGLContext • gdk_gl_context_realize() creates the underlying resources Calling gdk_gl_context_make_current() also realizes the context, so simple GL users do not need to care. Advanced users will want to call gdk_window_create_gl_context(), set up the optional requirements, and then call gdk_gl_context_realize(). If either of these two steps fails, it's possible to recover by changing the requirements, or simply creating a new GdkGLContext instance. https://bugzilla.gnome.org/show_bug.cgi?id=741946
2015-01-27 21:23:23 +00:00
gdk_gl_context_check_extensions (GdkGLContext *context)
gdkglcontext: Track whether to use GL_TEXTURE_2D or GL_TEXTURE_RECTANGL_ARB
2014-10-27 20:12:40 +00:00
{
GdkGLContextPrivate *priv = gdk_gl_context_get_instance_private (context);
Fix compiler warnings in the release build We have a bunch of debug-only variables that get set and never used outside of debug code paths, and the compiler is not happy about it.
2020-01-29 11:00:48 +00:00
gboolean gl_debug = FALSE;
GdkDisplay *display;
gdkglcontext: Track whether to use GL_TEXTURE_2D or GL_TEXTURE_RECTANGL_ARB
2014-10-27 20:12:40 +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 (!gdk_gl_context_is_realized (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
return;
if (priv->extensions_checked)
return;
GdkGLContext: check for GL_KHR_debug for GL debug output This is available in GLES.
2019-12-17 08:06:15 +00:00
priv->has_debug_output = epoxy_has_gl_extension ("GL_ARB_debug_output") ||
epoxy_has_gl_extension ("GL_KHR_debug");
GdkGLContext: Add a GL debug message callback If G_ENABLE_CONSISTENCY_CHECKS is defined (i.e. if our buildtype is 'debug'), add a opengl debug callback that prints all debug messages with a severity higher than SEVERITY_NOTIFICATION as a warning to the console.
2018-03-25 13:28:40 +00:00
gl: Install the debug message callback for gl-debug Always install the debug message callback when we can and GDK_DEBUG=gl-debug is specified. Previously, we were only installing the callback when the build was a non-optimized debug build.
2020-10-05 18:08:55 +00:00
display = gdk_draw_context_get_display (GDK_DRAW_CONTEXT (context));
Make the gl-debug debug flag always available No need to restrict this to debug builds.
2022-09-22 01:17:16 +00:00
gl_debug = (gdk_display_get_debug_flags (display) & GDK_DEBUG_GL_DEBUG) != 0;
gl: Install the debug message callback for gl-debug Always install the debug message callback when we can and GDK_DEBUG=gl-debug is specified. Previously, we were only installing the callback when the build was a non-optimized debug build.
2020-10-05 18:08:55 +00:00
Make the gl-debug debug flag always available No need to restrict this to debug builds.
2022-09-22 01:17:16 +00:00
if (priv->has_debug_output && gl_debug)
GdkGLContext: Add a GL debug message callback If G_ENABLE_CONSISTENCY_CHECKS is defined (i.e. if our buildtype is 'debug'), add a opengl debug callback that prints all debug messages with a severity higher than SEVERITY_NOTIFICATION as a warning to the console.
2018-03-25 13:28:40 +00:00
{
gdk_gl_context_make_current (context);
glEnable (GL_DEBUG_OUTPUT);
glEnable (GL_DEBUG_OUTPUT_SYNCHRONOUS);
glDebugMessageCallback (gl_debug_message_callback, NULL);
}
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_get_use_es (context))
gl: Add more OpenGL ES checks Check for the appropriate extensions depending on which type of API we're using.
2016-04-22 16:27:04 +00:00
{
gdkcontext: Make has_unpack_subimage() do the version check Makes the code look simpler when we actually use that function.
2023-08-12 20:13:07 +00:00
priv->has_unpack_subimage = gdk_gl_version_greater_equal (&priv->gl_version, &GDK_GL_VERSION_INIT (3, 0)) ||
epoxy_has_gl_extension ("GL_EXT_unpack_subimage");
GdkGLContext: Add internal functions for KHR_DEBUG calls This includes pushing and poping debug group messages and labeling objects.
2019-04-24 11:25:46 +00:00
priv->has_khr_debug = epoxy_has_gl_extension ("GL_KHR_debug");
glcontext: Check for GL_EXT_texture_format_BGRA8888 Check for this GLES extension and add a private getter.
2023-10-19 17:54:14 +00:00
priv->has_bgra = epoxy_has_gl_extension ("GL_EXT_texture_format_BGRA8888");
gl: Add more OpenGL ES checks Check for the appropriate extensions depending on which type of API we're using.
2016-04-22 16:27:04 +00:00
}
else
{
priv->has_unpack_subimage = TRUE;
GdkGLContext: Add internal functions for KHR_DEBUG calls This includes pushing and poping debug group messages and labeling objects.
2019-04-24 11:25:46 +00:00
priv->has_khr_debug = epoxy_has_gl_extension ("GL_KHR_debug");
glcontext: Check for GL_EXT_texture_format_BGRA8888 Check for this GLES extension and add a private getter.
2023-10-19 17:54:14 +00:00
priv->has_bgra = TRUE;
gl: Set legacy bit depending on OpenGL version GDK defaults to asking for an OpenGL 3.2 Core Profile, but if we get a legacy profile from the underlying windowing system, the OpenGL version will be fixed to 3.0. If that happens, we need to set the legacy bit on the GdkGLContext, since that bit will be used to determine the version and type of GLSL shaders that will be used by application and toolkit code alike.
2016-10-21 20:21:39 +00:00
/* We asked for a core profile, but we didn't get one, so we're in legacy mode */
glcontext: Use GdkGLVersion elsewhere ... and add a convenience API to generate GL versions from strings to make the gdk_gl_context_check() API nicer.
2023-04-25 17:32:12 +00:00
if (!gdk_gl_version_greater_equal (&priv->gl_version, &GDK_GL_VERSION_INIT (3, 2)))
gl: Set legacy bit depending on OpenGL version GDK defaults to asking for an OpenGL 3.2 Core Profile, but if we get a legacy profile from the underlying windowing system, the OpenGL version will be fixed to 3.0. If that happens, we need to set the legacy bit on the GdkGLContext, since that bit will be used to determine the version and type of GLSL shaders that will be used by application and toolkit code alike.
2016-10-21 20:21:39 +00:00
priv->is_legacy = TRUE;
gl: Add more OpenGL ES checks Check for the appropriate extensions depending on which type of API we're using.
2016-04-22 16:27:04 +00:00
}
Add gdk_gl_context_has_framebuffer_blit() This checks if the context supports GL_EXT_framebuffer_blit
2014-11-06 11:13:08 +00:00
Fix compiler warnings in the release build We have a bunch of debug-only variables that get set and never used outside of debug code paths, and the compiler is not happy about it.
2020-01-29 11:00:48 +00:00
if (priv->has_khr_debug && gl_debug)
gdkglcontext: Limit gl debug label length There's a maximum length we have to adhere to, otherwise GL throws a GL_INVALID_VALUE error.
2019-04-27 07:49:41 +00:00
{
priv->use_khr_debug = TRUE;
glGetIntegerv (GL_MAX_LABEL_LENGTH, &priv->max_debug_label_length);
}
gdkglcontext: Track whether to use GL_TEXTURE_2D or GL_TEXTURE_RECTANGL_ARB
2014-10-27 20:12:40 +00:00
glcontext: Use GdkGLVersion elsewhere ... and add a convenience API to generate GL versions from strings to make the gdk_gl_context_check() API nicer.
2023-04-25 17:32:12 +00:00
priv->has_half_float = gdk_gl_context_check_version (context, "3.0", "3.0") ||
gl: Check for the right extension name The extension is called GL_OES_vertex_half_float.
2024-02-12 21:10:18 +00:00
epoxy_has_gl_extension ("GL_OES_vertex_half_float");
gdk: Check OES_vertex_half_float GLES extension This will be checked in the GL renderer.
2022-05-05 17:08:32 +00:00
glcontext: Add a way to check for GLsync
2023-04-26 09:59:51 +00:00
priv->has_sync = gdk_gl_context_check_version (context, "3.2", "3.0") ||
epoxy_has_gl_extension ("GL_ARB_sync") ||
glcontext: Fix typo in Apple extension name
2023-07-01 20:37:05 +00:00
epoxy_has_gl_extension ("GL_APPLE_sync");
glcontext: Add a way to check for GLsync
2023-04-26 09:59:51 +00:00
glcontext: Add gdk_gl_context_get_memory_flags() Checks which features of a given memory format are supported by the current GL implementation. We check: * usable: Can be used as a texture with NEAREST filter * renderable: Can be used as a render target * filterable: Can be used with GL_LINEAR In normal GL, all formats are all of these things, but GLES is a lot more picky. So far nobody uses this.
2023-12-07 04:45:59 +00:00
gdk_gl_context_init_memory_flags (context);
gl: Print max texture size in debug output This is useful information.
2023-03-15 02:12:00 +00:00
{
int max_texture_size;
glGetIntegerv (GL_MAX_TEXTURE_SIZE, &max_texture_size);
GDK_DISPLAY_DEBUG (gdk_draw_context_get_display (GDK_DRAW_CONTEXT (context)), OPENGL,
"%s version: %d.%d (%s)\n"
"* GLSL version: %s\n"
"* Max texture size: %d\n"
"* Extensions checked:\n"
" - GL_KHR_debug: %s\n"
" - GL_EXT_unpack_subimage: %s\n"
glcontext: Add a way to check for GLsync
2023-04-26 09:59:51 +00:00
" - half float: %s\n"
Revert "glcontext: Better debug spew" This reverts commit 30e14f73fa8d1af1a5f73a9c48ae8129403efc5a.
2023-10-29 18:44:29 +00:00
" - sync: %s\n"
" - bgra: %s",
gl: Print max texture size in debug output This is useful information.
2023-03-15 02:12:00 +00:00
gdk_gl_context_get_use_es (context) ? "OpenGL ES" : "OpenGL",
glcontext: Use GdkGLVersion elsewhere ... and add a convenience API to generate GL versions from strings to make the gdk_gl_context_check() API nicer.
2023-04-25 17:32:12 +00:00
gdk_gl_version_get_major (&priv->gl_version), gdk_gl_version_get_minor (&priv->gl_version),
gl: Print max texture size in debug output This is useful information.
2023-03-15 02:12:00 +00:00
priv->is_legacy ? "legacy" : "core",
glGetString (GL_SHADING_LANGUAGE_VERSION),
max_texture_size,
priv->has_khr_debug ? "yes" : "no",
priv->has_unpack_subimage ? "yes" : "no",
glcontext: Add a way to check for GLsync
2023-04-26 09:59:51 +00:00
priv->has_half_float ? "yes" : "no",
Revert "glcontext: Better debug spew" This reverts commit 30e14f73fa8d1af1a5f73a9c48ae8129403efc5a.
2023-10-29 18:44:29 +00:00
priv->has_sync ? "yes" : "no",
priv->has_bgra ? "yes" : "no");
gl: Print max texture size in debug output This is useful information.
2023-03-15 02:12:00 +00:00
}
gl: Add more debugging notes https://bugzilla.gnome.org/show_bug.cgi?id=741946
2015-02-05 16:23:04 +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
priv->extensions_checked = TRUE;
gdkglcontext: Track whether to use GL_TEXTURE_2D or GL_TEXTURE_RECTANGL_ARB
2014-10-27 20:12:40 +00:00
}
gdk: Add private GLContext::is_current() check ... and use this check in gdk_gl_context_make_current() and gdk_gl_context_get_current() to make sure the context really is still current. The context no longer being current can happen when external GL implementations make their own contexts current in the same threads GDK contexts are used in. And that can happen for example by WebKit. Theoretically, this should also allow external EGL code to run in X11 applications when GDK chooses to use GLX, but I didn't try it. Fixes #5392
2023-02-02 01:49:56 +00:00
static gboolean
gdk_gl_context_check_is_current (GdkGLContext *context)
{
return GDK_GL_CONTEXT_GET_CLASS (context)->is_current (context);
}
gdk: Add support for OpenGL This adds the new type GdkGLContext that wraps an OpenGL context for a particular native window. It also adds support for the gdk paint machinery to use OpenGL to draw everything. As soon as anyone creates a GL context for a native window we create a "paint context" for that GdkWindow and switch to using GL for painting it. This commit contains only an implementation for X11 (using GLX). The way painting works is that all client gl contexts draw into offscreen buffers rather than directly to the back buffer, and the way something gets onto the window is by using gdk_cairo_draw_from_gl() to draw part of that buffer onto the draw cairo context. As a fallback (if we're doing redirected drawing or some effect like a cairo_push_group()) we read back the gl buffer into memory and composite using cairo. This means that GL rendering works in all cases, including rendering to a PDF. However, this is not particularly fast. In the *typical* case, where we're drawing directly to the window in the regular paint loop we hit the fast path. The fast path uses opengl to draw the buffer to the window back buffer, either by blitting or texturing. Then we track the region that was drawn, and when the draw ends we paint the normal cairo surface to the window (using texture-from-pixmap in the X11 case, or texture from cairo image otherwise) in the regions where there is no gl painted. There are some complexities wrt layering of gl and cairo areas though: * We track via gdk_window_mark_paint_from_clip() whenever gtk is painting over a region we previously rendered with opengl (flushed_region). This area (needs_blend_region) is blended rather than copied at the end of the frame. * If we're drawing a gl texture with alpha we first copy the current cairo_surface inside the target region to the back buffer before we blend over it. These two operations allow us full stacking of transparent gl and cairo regions.
2014-10-09 08:45:44 +00:00
/**
* gdk_gl_context_make_current:
docs: Rework the gdk docs Convert links, make things more concise.
2021-02-21 05:13:57 +00:00
* @context: a `GdkGLContext`
gdk: Add support for OpenGL This adds the new type GdkGLContext that wraps an OpenGL context for a particular native window. It also adds support for the gdk paint machinery to use OpenGL to draw everything. As soon as anyone creates a GL context for a native window we create a "paint context" for that GdkWindow and switch to using GL for painting it. This commit contains only an implementation for X11 (using GLX). The way painting works is that all client gl contexts draw into offscreen buffers rather than directly to the back buffer, and the way something gets onto the window is by using gdk_cairo_draw_from_gl() to draw part of that buffer onto the draw cairo context. As a fallback (if we're doing redirected drawing or some effect like a cairo_push_group()) we read back the gl buffer into memory and composite using cairo. This means that GL rendering works in all cases, including rendering to a PDF. However, this is not particularly fast. In the *typical* case, where we're drawing directly to the window in the regular paint loop we hit the fast path. The fast path uses opengl to draw the buffer to the window back buffer, either by blitting or texturing. Then we track the region that was drawn, and when the draw ends we paint the normal cairo surface to the window (using texture-from-pixmap in the X11 case, or texture from cairo image otherwise) in the regions where there is no gl painted. There are some complexities wrt layering of gl and cairo areas though: * We track via gdk_window_mark_paint_from_clip() whenever gtk is painting over a region we previously rendered with opengl (flushed_region). This area (needs_blend_region) is blended rather than copied at the end of the frame. * If we're drawing a gl texture with alpha we first copy the current cairo_surface inside the target region to the back buffer before we blend over it. These two operations allow us full stacking of transparent gl and cairo regions.
2014-10-09 08:45:44 +00:00
*
* Makes the @context the current one.
*/
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
void
gdk: Add support for OpenGL This adds the new type GdkGLContext that wraps an OpenGL context for a particular native window. It also adds support for the gdk paint machinery to use OpenGL to draw everything. As soon as anyone creates a GL context for a native window we create a "paint context" for that GdkWindow and switch to using GL for painting it. This commit contains only an implementation for X11 (using GLX). The way painting works is that all client gl contexts draw into offscreen buffers rather than directly to the back buffer, and the way something gets onto the window is by using gdk_cairo_draw_from_gl() to draw part of that buffer onto the draw cairo context. As a fallback (if we're doing redirected drawing or some effect like a cairo_push_group()) we read back the gl buffer into memory and composite using cairo. This means that GL rendering works in all cases, including rendering to a PDF. However, this is not particularly fast. In the *typical* case, where we're drawing directly to the window in the regular paint loop we hit the fast path. The fast path uses opengl to draw the buffer to the window back buffer, either by blitting or texturing. Then we track the region that was drawn, and when the draw ends we paint the normal cairo surface to the window (using texture-from-pixmap in the X11 case, or texture from cairo image otherwise) in the regions where there is no gl painted. There are some complexities wrt layering of gl and cairo areas though: * We track via gdk_window_mark_paint_from_clip() whenever gtk is painting over a region we previously rendered with opengl (flushed_region). This area (needs_blend_region) is blended rather than copied at the end of the frame. * If we're drawing a gl texture with alpha we first copy the current cairo_surface inside the target region to the back buffer before we blend over it. These two operations allow us full stacking of transparent gl and cairo regions.
2014-10-09 08:45:44 +00:00
gdk_gl_context_make_current (GdkGLContext *context)
{
gl: Store the context::in-frame state in the current context Do not treat the context as already current when the value of context::in-frame changes. This is so we can bind to EGL_NO_SURFACE if context::in-frame == false and to context::surface if context::in-frame == true. This allows getting rid of the attached property in future commits.
2021-07-06 02:47:15 +00:00
MaskedContext *current, *masked_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
gboolean surfaceless;
gdk: Add support for OpenGL This adds the new type GdkGLContext that wraps an OpenGL context for a particular native window. It also adds support for the gdk paint machinery to use OpenGL to draw everything. As soon as anyone creates a GL context for a native window we create a "paint context" for that GdkWindow and switch to using GL for painting it. This commit contains only an implementation for X11 (using GLX). The way painting works is that all client gl contexts draw into offscreen buffers rather than directly to the back buffer, and the way something gets onto the window is by using gdk_cairo_draw_from_gl() to draw part of that buffer onto the draw cairo context. As a fallback (if we're doing redirected drawing or some effect like a cairo_push_group()) we read back the gl buffer into memory and composite using cairo. This means that GL rendering works in all cases, including rendering to a PDF. However, this is not particularly fast. In the *typical* case, where we're drawing directly to the window in the regular paint loop we hit the fast path. The fast path uses opengl to draw the buffer to the window back buffer, either by blitting or texturing. Then we track the region that was drawn, and when the draw ends we paint the normal cairo surface to the window (using texture-from-pixmap in the X11 case, or texture from cairo image otherwise) in the regions where there is no gl painted. There are some complexities wrt layering of gl and cairo areas though: * We track via gdk_window_mark_paint_from_clip() whenever gtk is painting over a region we previously rendered with opengl (flushed_region). This area (needs_blend_region) is blended rather than copied at the end of the frame. * If we're drawing a gl texture with alpha we first copy the current cairo_surface inside the target region to the back buffer before we blend over it. These two operations allow us full stacking of transparent gl and cairo regions.
2014-10-09 08:45:44 +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
g_return_if_fail (GDK_IS_GL_CONTEXT (context));
gdk: Add support for OpenGL This adds the new type GdkGLContext that wraps an OpenGL context for a particular native window. It also adds support for the gdk paint machinery to use OpenGL to draw everything. As soon as anyone creates a GL context for a native window we create a "paint context" for that GdkWindow and switch to using GL for painting it. This commit contains only an implementation for X11 (using GLX). The way painting works is that all client gl contexts draw into offscreen buffers rather than directly to the back buffer, and the way something gets onto the window is by using gdk_cairo_draw_from_gl() to draw part of that buffer onto the draw cairo context. As a fallback (if we're doing redirected drawing or some effect like a cairo_push_group()) we read back the gl buffer into memory and composite using cairo. This means that GL rendering works in all cases, including rendering to a PDF. However, this is not particularly fast. In the *typical* case, where we're drawing directly to the window in the regular paint loop we hit the fast path. The fast path uses opengl to draw the buffer to the window back buffer, either by blitting or texturing. Then we track the region that was drawn, and when the draw ends we paint the normal cairo surface to the window (using texture-from-pixmap in the X11 case, or texture from cairo image otherwise) in the regions where there is no gl painted. There are some complexities wrt layering of gl and cairo areas though: * We track via gdk_window_mark_paint_from_clip() whenever gtk is painting over a region we previously rendered with opengl (flushed_region). This area (needs_blend_region) is blended rather than copied at the end of the frame. * If we're drawing a gl texture with alpha we first copy the current cairo_surface inside the target region to the back buffer before we blend over it. These two operations allow us full stacking of transparent gl and cairo regions.
2014-10-09 08:45:44 +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
surfaceless = !gdk_draw_context_is_in_frame (GDK_DRAW_CONTEXT (context));
masked_context = mask_context (context, surfaceless);
gl: Store the context::in-frame state in the current context Do not treat the context as already current when the value of context::in-frame changes. This is so we can bind to EGL_NO_SURFACE if context::in-frame == false and to context::surface if context::in-frame == true. This allows getting rid of the attached property in future commits.
2021-07-06 02:47:15 +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
current = g_private_get (&thread_current_context);
gdk: Add private GLContext::is_current() check ... and use this check in gdk_gl_context_make_current() and gdk_gl_context_get_current() to make sure the context really is still current. The context no longer being current can happen when external GL implementations make their own contexts current in the same threads GDK contexts are used in. And that can happen for example by WebKit. Theoretically, this should also allow external EGL code to run in X11 applications when GDK chooses to use GLX, but I didn't try it. Fixes #5392
2023-02-02 01:49:56 +00:00
if (current == masked_context && gdk_gl_context_check_is_current (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;
gdkglcontext: Track whether to use GL_TEXTURE_2D or GL_TEXTURE_RECTANGL_ARB
2014-10-27 20:12:40 +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
/* we need to realize the GdkGLContext if it wasn't explicitly realized */
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_realized (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
{
GError *error = NULL;
gdk_gl_context_realize (context, &error);
if (error != NULL)
{
g_critical ("Could not realize the GL context: %s", error->message);
g_error_free (error);
return;
}
}
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 (!GDK_GL_CONTEXT_GET_CLASS (context)->make_current (context, surfaceless))
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
{
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
g_warning ("gdk_gl_context_make_current() failed");
return;
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
}
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
g_object_ref (context);
g_private_replace (&thread_current_context, masked_context);
gdk_gl_context_check_extensions (context);
gdk: Add support for OpenGL This adds the new type GdkGLContext that wraps an OpenGL context for a particular native window. It also adds support for the gdk paint machinery to use OpenGL to draw everything. As soon as anyone creates a GL context for a native window we create a "paint context" for that GdkWindow and switch to using GL for painting it. This commit contains only an implementation for X11 (using GLX). The way painting works is that all client gl contexts draw into offscreen buffers rather than directly to the back buffer, and the way something gets onto the window is by using gdk_cairo_draw_from_gl() to draw part of that buffer onto the draw cairo context. As a fallback (if we're doing redirected drawing or some effect like a cairo_push_group()) we read back the gl buffer into memory and composite using cairo. This means that GL rendering works in all cases, including rendering to a PDF. However, this is not particularly fast. In the *typical* case, where we're drawing directly to the window in the regular paint loop we hit the fast path. The fast path uses opengl to draw the buffer to the window back buffer, either by blitting or texturing. Then we track the region that was drawn, and when the draw ends we paint the normal cairo surface to the window (using texture-from-pixmap in the X11 case, or texture from cairo image otherwise) in the regions where there is no gl painted. There are some complexities wrt layering of gl and cairo areas though: * We track via gdk_window_mark_paint_from_clip() whenever gtk is painting over a region we previously rendered with opengl (flushed_region). This area (needs_blend_region) is blended rather than copied at the end of the frame. * If we're drawing a gl texture with alpha we first copy the current cairo_surface inside the target region to the back buffer before we blend over it. These two operations allow us full stacking of transparent gl and cairo regions.
2014-10-09 08:45:44 +00:00
}
GdkGLContext: Add display property We need to use this in the code path where we make the context non-current during destroy, because at that point the window could be destroyed and gdk_window_get_display() would return NULL.
2014-11-03 12:20:55 +00:00
/**
* gdk_gl_context_get_display:
docs: Rework the gdk docs Convert links, make things more concise.
2021-02-21 05:13:57 +00:00
* @context: a `GdkGLContext`
GdkGLContext: Add display property We need to use this in the code path where we make the context non-current during destroy, because at that point the window could be destroyed and gdk_window_get_display() would return NULL.
2014-11-03 12:20:55 +00:00
*
docs: Rework the gdk docs Convert links, make things more concise.
2021-02-21 05:13:57 +00:00
* Retrieves the display the @context is created for
GdkGLContext: Add display property We need to use this in the code path where we make the context non-current during destroy, because at that point the window could be destroyed and gdk_window_get_display() would return NULL.
2014-11-03 12:20:55 +00:00
*
docs: Reduce redundancy Remove a boatload of "or %NULL" from nullable parameters and return values. gi-docgen generates suitable text from the annotation that we don't need to duplicate. This adds a few missing nullable annotations too.
2021-05-21 00:45:06 +00:00
* Returns: (nullable) (transfer none): a `GdkDisplay`
GdkGLContext: Add display property We need to use this in the code path where we make the context non-current during destroy, because at that point the window could be destroyed and gdk_window_get_display() would return NULL.
2014-11-03 12:20:55 +00:00
*/
GdkDisplay *
gdk_gl_context_get_display (GdkGLContext *context)
{
g_return_val_if_fail (GDK_IS_GL_CONTEXT (context), NULL);
gdk: Turn GdkGLContext into a GdkDrawContext
2016-11-28 16:36:37 +00:00
return gdk_draw_context_get_display (GDK_DRAW_CONTEXT (context));
GdkGLContext: Add display property We need to use this in the code path where we make the context non-current during destroy, because at that point the window could be destroyed and gdk_window_get_display() would return NULL.
2014-11-03 12:20:55 +00:00
}
gdk: Add support for OpenGL This adds the new type GdkGLContext that wraps an OpenGL context for a particular native window. It also adds support for the gdk paint machinery to use OpenGL to draw everything. As soon as anyone creates a GL context for a native window we create a "paint context" for that GdkWindow and switch to using GL for painting it. This commit contains only an implementation for X11 (using GLX). The way painting works is that all client gl contexts draw into offscreen buffers rather than directly to the back buffer, and the way something gets onto the window is by using gdk_cairo_draw_from_gl() to draw part of that buffer onto the draw cairo context. As a fallback (if we're doing redirected drawing or some effect like a cairo_push_group()) we read back the gl buffer into memory and composite using cairo. This means that GL rendering works in all cases, including rendering to a PDF. However, this is not particularly fast. In the *typical* case, where we're drawing directly to the window in the regular paint loop we hit the fast path. The fast path uses opengl to draw the buffer to the window back buffer, either by blitting or texturing. Then we track the region that was drawn, and when the draw ends we paint the normal cairo surface to the window (using texture-from-pixmap in the X11 case, or texture from cairo image otherwise) in the regions where there is no gl painted. There are some complexities wrt layering of gl and cairo areas though: * We track via gdk_window_mark_paint_from_clip() whenever gtk is painting over a region we previously rendered with opengl (flushed_region). This area (needs_blend_region) is blended rather than copied at the end of the frame. * If we're drawing a gl texture with alpha we first copy the current cairo_surface inside the target region to the back buffer before we blend over it. These two operations allow us full stacking of transparent gl and cairo regions.
2014-10-09 08:45:44 +00:00
/**
GdkSurface: Rename various functions and variables This is an automatic rename of various things related to the window->surface rename. Public symbols changed by this is: GDK_MODE_WINDOW gdk_device_get_window_at_position gdk_device_get_window_at_position_double gdk_device_get_last_event_window gdk_display_get_monitor_at_window gdk_drag_context_get_source_window gdk_drag_context_get_dest_window gdk_drag_context_get_drag_window gdk_draw_context_get_window gdk_drawing_context_get_window gdk_gl_context_get_window gdk_synthesize_window_state gdk_surface_get_window_type gdk_x11_display_set_window_scale gsk_renderer_new_for_window gsk_renderer_get_window gtk_text_view_buffer_to_window_coords gtk_tree_view_convert_widget_to_bin_window_coords gtk_tree_view_convert_tree_to_bin_window_coords The commands that generated this are: git sed -f g "GDK window" "GDK surface" git sed -f g window_impl surface_impl (cd gdk; git sed -f g impl_window impl_surface) git sed -f g WINDOW_IMPL SURFACE_IMPL git sed -f g GDK_MODE_WINDOW GDK_MODE_SURFACE git sed -f g gdk_draw_context_get_window gdk_draw_context_get_surface git sed -f g gdk_drawing_context_get_window gdk_drawing_context_get_surface git sed -f g gdk_gl_context_get_window gdk_gl_context_get_surface git sed -f g gsk_renderer_get_window gsk_renderer_get_surface git sed -f g gsk_renderer_new_for_window gsk_renderer_new_for_surface (cd gdk; git sed -f g window_type surface_type) git sed -f g gdk_surface_get_window_type gdk_surface_get_surface_type git sed -f g window_at_position surface_at_position git sed -f g event_window event_surface git sed -f g window_coord surface_coord git sed -f g window_state surface_state git sed -f g window_cursor surface_cursor git sed -f g window_scale surface_scale git sed -f g window_events surface_events git sed -f g monitor_at_window monitor_at_surface git sed -f g window_under_pointer surface_under_pointer (cd gdk; git sed -f g for_window for_surface) git sed -f g window_anchor surface_anchor git sed -f g WINDOW_IS_TOPLEVEL SURFACE_IS_TOPLEVEL git sed -f g native_window native_surface git sed -f g source_window source_surface git sed -f g dest_window dest_surface git sed -f g drag_window drag_surface git sed -f g input_window input_surface git checkout NEWS* po-properties po docs/reference/gtk/migrating-3to4.xml
2018-03-20 11:05:26 +00:00
* gdk_gl_context_get_surface:
docs: Rework the gdk docs Convert links, make things more concise.
2021-02-21 05:13:57 +00:00
* @context: a `GdkGLContext`
gdk: Add support for OpenGL This adds the new type GdkGLContext that wraps an OpenGL context for a particular native window. It also adds support for the gdk paint machinery to use OpenGL to draw everything. As soon as anyone creates a GL context for a native window we create a "paint context" for that GdkWindow and switch to using GL for painting it. This commit contains only an implementation for X11 (using GLX). The way painting works is that all client gl contexts draw into offscreen buffers rather than directly to the back buffer, and the way something gets onto the window is by using gdk_cairo_draw_from_gl() to draw part of that buffer onto the draw cairo context. As a fallback (if we're doing redirected drawing or some effect like a cairo_push_group()) we read back the gl buffer into memory and composite using cairo. This means that GL rendering works in all cases, including rendering to a PDF. However, this is not particularly fast. In the *typical* case, where we're drawing directly to the window in the regular paint loop we hit the fast path. The fast path uses opengl to draw the buffer to the window back buffer, either by blitting or texturing. Then we track the region that was drawn, and when the draw ends we paint the normal cairo surface to the window (using texture-from-pixmap in the X11 case, or texture from cairo image otherwise) in the regions where there is no gl painted. There are some complexities wrt layering of gl and cairo areas though: * We track via gdk_window_mark_paint_from_clip() whenever gtk is painting over a region we previously rendered with opengl (flushed_region). This area (needs_blend_region) is blended rather than copied at the end of the frame. * If we're drawing a gl texture with alpha we first copy the current cairo_surface inside the target region to the back buffer before we blend over it. These two operations allow us full stacking of transparent gl and cairo regions.
2014-10-09 08:45:44 +00:00
*
docs: Rework the gdk docs Convert links, make things more concise.
2021-02-21 05:13:57 +00:00
* Retrieves the surface used by the @context.
gdk: Add support for OpenGL This adds the new type GdkGLContext that wraps an OpenGL context for a particular native window. It also adds support for the gdk paint machinery to use OpenGL to draw everything. As soon as anyone creates a GL context for a native window we create a "paint context" for that GdkWindow and switch to using GL for painting it. This commit contains only an implementation for X11 (using GLX). The way painting works is that all client gl contexts draw into offscreen buffers rather than directly to the back buffer, and the way something gets onto the window is by using gdk_cairo_draw_from_gl() to draw part of that buffer onto the draw cairo context. As a fallback (if we're doing redirected drawing or some effect like a cairo_push_group()) we read back the gl buffer into memory and composite using cairo. This means that GL rendering works in all cases, including rendering to a PDF. However, this is not particularly fast. In the *typical* case, where we're drawing directly to the window in the regular paint loop we hit the fast path. The fast path uses opengl to draw the buffer to the window back buffer, either by blitting or texturing. Then we track the region that was drawn, and when the draw ends we paint the normal cairo surface to the window (using texture-from-pixmap in the X11 case, or texture from cairo image otherwise) in the regions where there is no gl painted. There are some complexities wrt layering of gl and cairo areas though: * We track via gdk_window_mark_paint_from_clip() whenever gtk is painting over a region we previously rendered with opengl (flushed_region). This area (needs_blend_region) is blended rather than copied at the end of the frame. * If we're drawing a gl texture with alpha we first copy the current cairo_surface inside the target region to the back buffer before we blend over it. These two operations allow us full stacking of transparent gl and cairo regions.
2014-10-09 08:45:44 +00:00
*
docs: Reduce redundancy Remove a boatload of "or %NULL" from nullable parameters and return values. gi-docgen generates suitable text from the annotation that we don't need to duplicate. This adds a few missing nullable annotations too.
2021-05-21 00:45:06 +00:00
* Returns: (nullable) (transfer none): a `GdkSurface`
gdk: Add support for OpenGL This adds the new type GdkGLContext that wraps an OpenGL context for a particular native window. It also adds support for the gdk paint machinery to use OpenGL to draw everything. As soon as anyone creates a GL context for a native window we create a "paint context" for that GdkWindow and switch to using GL for painting it. This commit contains only an implementation for X11 (using GLX). The way painting works is that all client gl contexts draw into offscreen buffers rather than directly to the back buffer, and the way something gets onto the window is by using gdk_cairo_draw_from_gl() to draw part of that buffer onto the draw cairo context. As a fallback (if we're doing redirected drawing or some effect like a cairo_push_group()) we read back the gl buffer into memory and composite using cairo. This means that GL rendering works in all cases, including rendering to a PDF. However, this is not particularly fast. In the *typical* case, where we're drawing directly to the window in the regular paint loop we hit the fast path. The fast path uses opengl to draw the buffer to the window back buffer, either by blitting or texturing. Then we track the region that was drawn, and when the draw ends we paint the normal cairo surface to the window (using texture-from-pixmap in the X11 case, or texture from cairo image otherwise) in the regions where there is no gl painted. There are some complexities wrt layering of gl and cairo areas though: * We track via gdk_window_mark_paint_from_clip() whenever gtk is painting over a region we previously rendered with opengl (flushed_region). This area (needs_blend_region) is blended rather than copied at the end of the frame. * If we're drawing a gl texture with alpha we first copy the current cairo_surface inside the target region to the back buffer before we blend over it. These two operations allow us full stacking of transparent gl and cairo regions.
2014-10-09 08:45:44 +00:00
*/
GdkWindow -> GdkSurface initial type rename This renames the GdkWindow class and related classes (impl, backend subclasses) to surface. Additionally it renames related types: GdkWindowAttr, GdkWindowPaint, GdkWindowWindowClass, GdkWindowType, GdkWindowTypeHint, GdkWindowHints, GdkWindowState, GdkWindowEdge This is an automatic conversion using the below commands: git sed -f g GdkWindowWindowClass GdkSurfaceSurfaceClass git sed -f g GdkWindow GdkSurface git sed -f g "gdk_window\([ _\(\),;]\|$\)" "gdk_surface\1" # Avoid hitting gdk_windowing git sed -f g "GDK_WINDOW\([ _\(]\|$\)" "GDK_SURFACE\1" # Avoid hitting GDK_WINDOWING git sed "GDK_\([A-Z]*\)IS_WINDOW\([_ (]\|$\)" "GDK_\1IS_SURFACE\2" git sed GDK_TYPE_WINDOW GDK_TYPE_SURFACE git sed -f g GdkPointerWindowInfo GdkPointerSurfaceInfo git sed -f g "BROADWAY_WINDOW" "BROADWAY_SURFACE" git sed -f g "broadway_window" "broadway_surface" git sed -f g "BroadwayWindow" "BroadwaySurface" git sed -f g "WAYLAND_WINDOW" "WAYLAND_SURFACE" git sed -f g "wayland_window" "wayland_surface" git sed -f g "WaylandWindow" "WaylandSurface" git sed -f g "X11_WINDOW" "X11_SURFACE" git sed -f g "x11_window" "x11_surface" git sed -f g "X11Window" "X11Surface" git sed -f g "WIN32_WINDOW" "WIN32_SURFACE" git sed -f g "win32_window" "win32_surface" git sed -f g "Win32Window" "Win32Surface" git sed -f g "QUARTZ_WINDOW" "QUARTZ_SURFACE" git sed -f g "quartz_window" "quartz_surface" git sed -f g "QuartzWindow" "QuartzSurface" git checkout NEWS* po-properties
2018-03-20 10:40:08 +00:00
GdkSurface *
GdkSurface: Rename various functions and variables This is an automatic rename of various things related to the window->surface rename. Public symbols changed by this is: GDK_MODE_WINDOW gdk_device_get_window_at_position gdk_device_get_window_at_position_double gdk_device_get_last_event_window gdk_display_get_monitor_at_window gdk_drag_context_get_source_window gdk_drag_context_get_dest_window gdk_drag_context_get_drag_window gdk_draw_context_get_window gdk_drawing_context_get_window gdk_gl_context_get_window gdk_synthesize_window_state gdk_surface_get_window_type gdk_x11_display_set_window_scale gsk_renderer_new_for_window gsk_renderer_get_window gtk_text_view_buffer_to_window_coords gtk_tree_view_convert_widget_to_bin_window_coords gtk_tree_view_convert_tree_to_bin_window_coords The commands that generated this are: git sed -f g "GDK window" "GDK surface" git sed -f g window_impl surface_impl (cd gdk; git sed -f g impl_window impl_surface) git sed -f g WINDOW_IMPL SURFACE_IMPL git sed -f g GDK_MODE_WINDOW GDK_MODE_SURFACE git sed -f g gdk_draw_context_get_window gdk_draw_context_get_surface git sed -f g gdk_drawing_context_get_window gdk_drawing_context_get_surface git sed -f g gdk_gl_context_get_window gdk_gl_context_get_surface git sed -f g gsk_renderer_get_window gsk_renderer_get_surface git sed -f g gsk_renderer_new_for_window gsk_renderer_new_for_surface (cd gdk; git sed -f g window_type surface_type) git sed -f g gdk_surface_get_window_type gdk_surface_get_surface_type git sed -f g window_at_position surface_at_position git sed -f g event_window event_surface git sed -f g window_coord surface_coord git sed -f g window_state surface_state git sed -f g window_cursor surface_cursor git sed -f g window_scale surface_scale git sed -f g window_events surface_events git sed -f g monitor_at_window monitor_at_surface git sed -f g window_under_pointer surface_under_pointer (cd gdk; git sed -f g for_window for_surface) git sed -f g window_anchor surface_anchor git sed -f g WINDOW_IS_TOPLEVEL SURFACE_IS_TOPLEVEL git sed -f g native_window native_surface git sed -f g source_window source_surface git sed -f g dest_window dest_surface git sed -f g drag_window drag_surface git sed -f g input_window input_surface git checkout NEWS* po-properties po docs/reference/gtk/migrating-3to4.xml
2018-03-20 11:05:26 +00:00
gdk_gl_context_get_surface (GdkGLContext *context)
gdk: Add support for OpenGL This adds the new type GdkGLContext that wraps an OpenGL context for a particular native window. It also adds support for the gdk paint machinery to use OpenGL to draw everything. As soon as anyone creates a GL context for a native window we create a "paint context" for that GdkWindow and switch to using GL for painting it. This commit contains only an implementation for X11 (using GLX). The way painting works is that all client gl contexts draw into offscreen buffers rather than directly to the back buffer, and the way something gets onto the window is by using gdk_cairo_draw_from_gl() to draw part of that buffer onto the draw cairo context. As a fallback (if we're doing redirected drawing or some effect like a cairo_push_group()) we read back the gl buffer into memory and composite using cairo. This means that GL rendering works in all cases, including rendering to a PDF. However, this is not particularly fast. In the *typical* case, where we're drawing directly to the window in the regular paint loop we hit the fast path. The fast path uses opengl to draw the buffer to the window back buffer, either by blitting or texturing. Then we track the region that was drawn, and when the draw ends we paint the normal cairo surface to the window (using texture-from-pixmap in the X11 case, or texture from cairo image otherwise) in the regions where there is no gl painted. There are some complexities wrt layering of gl and cairo areas though: * We track via gdk_window_mark_paint_from_clip() whenever gtk is painting over a region we previously rendered with opengl (flushed_region). This area (needs_blend_region) is blended rather than copied at the end of the frame. * If we're drawing a gl texture with alpha we first copy the current cairo_surface inside the target region to the back buffer before we blend over it. These two operations allow us full stacking of transparent gl and cairo regions.
2014-10-09 08:45:44 +00:00
{
g_return_val_if_fail (GDK_IS_GL_CONTEXT (context), NULL);
GdkSurface: Rename various functions and variables This is an automatic rename of various things related to the window->surface rename. Public symbols changed by this is: GDK_MODE_WINDOW gdk_device_get_window_at_position gdk_device_get_window_at_position_double gdk_device_get_last_event_window gdk_display_get_monitor_at_window gdk_drag_context_get_source_window gdk_drag_context_get_dest_window gdk_drag_context_get_drag_window gdk_draw_context_get_window gdk_drawing_context_get_window gdk_gl_context_get_window gdk_synthesize_window_state gdk_surface_get_window_type gdk_x11_display_set_window_scale gsk_renderer_new_for_window gsk_renderer_get_window gtk_text_view_buffer_to_window_coords gtk_tree_view_convert_widget_to_bin_window_coords gtk_tree_view_convert_tree_to_bin_window_coords The commands that generated this are: git sed -f g "GDK window" "GDK surface" git sed -f g window_impl surface_impl (cd gdk; git sed -f g impl_window impl_surface) git sed -f g WINDOW_IMPL SURFACE_IMPL git sed -f g GDK_MODE_WINDOW GDK_MODE_SURFACE git sed -f g gdk_draw_context_get_window gdk_draw_context_get_surface git sed -f g gdk_drawing_context_get_window gdk_drawing_context_get_surface git sed -f g gdk_gl_context_get_window gdk_gl_context_get_surface git sed -f g gsk_renderer_get_window gsk_renderer_get_surface git sed -f g gsk_renderer_new_for_window gsk_renderer_new_for_surface (cd gdk; git sed -f g window_type surface_type) git sed -f g gdk_surface_get_window_type gdk_surface_get_surface_type git sed -f g window_at_position surface_at_position git sed -f g event_window event_surface git sed -f g window_coord surface_coord git sed -f g window_state surface_state git sed -f g window_cursor surface_cursor git sed -f g window_scale surface_scale git sed -f g window_events surface_events git sed -f g monitor_at_window monitor_at_surface git sed -f g window_under_pointer surface_under_pointer (cd gdk; git sed -f g for_window for_surface) git sed -f g window_anchor surface_anchor git sed -f g WINDOW_IS_TOPLEVEL SURFACE_IS_TOPLEVEL git sed -f g native_window native_surface git sed -f g source_window source_surface git sed -f g dest_window dest_surface git sed -f g drag_window drag_surface git sed -f g input_window input_surface git checkout NEWS* po-properties po docs/reference/gtk/migrating-3to4.xml
2018-03-20 11:05:26 +00:00
return gdk_draw_context_get_surface (GDK_DRAW_CONTEXT (context));
gdk: Add support for OpenGL This adds the new type GdkGLContext that wraps an OpenGL context for a particular native window. It also adds support for the gdk paint machinery to use OpenGL to draw everything. As soon as anyone creates a GL context for a native window we create a "paint context" for that GdkWindow and switch to using GL for painting it. This commit contains only an implementation for X11 (using GLX). The way painting works is that all client gl contexts draw into offscreen buffers rather than directly to the back buffer, and the way something gets onto the window is by using gdk_cairo_draw_from_gl() to draw part of that buffer onto the draw cairo context. As a fallback (if we're doing redirected drawing or some effect like a cairo_push_group()) we read back the gl buffer into memory and composite using cairo. This means that GL rendering works in all cases, including rendering to a PDF. However, this is not particularly fast. In the *typical* case, where we're drawing directly to the window in the regular paint loop we hit the fast path. The fast path uses opengl to draw the buffer to the window back buffer, either by blitting or texturing. Then we track the region that was drawn, and when the draw ends we paint the normal cairo surface to the window (using texture-from-pixmap in the X11 case, or texture from cairo image otherwise) in the regions where there is no gl painted. There are some complexities wrt layering of gl and cairo areas though: * We track via gdk_window_mark_paint_from_clip() whenever gtk is painting over a region we previously rendered with opengl (flushed_region). This area (needs_blend_region) is blended rather than copied at the end of the frame. * If we're drawing a gl texture with alpha we first copy the current cairo_surface inside the target region to the back buffer before we blend over it. These two operations allow us full stacking of transparent gl and cairo regions.
2014-10-09 08:45:44 +00:00
}
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
/**
glcontext: Add property annotations Connect properties, getters, and setters with annotations.
2021-02-25 01:04:17 +00:00
* gdk_gl_context_get_shared_context: (attributes org.gtk.Method.get_property=shared-context)
docs: Rework the gdk docs Convert links, make things more concise.
2021-02-21 05:13:57 +00:00
* @context: a `GdkGLContext`
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
*
gl: Deprecate gdk_gl_context_get_shared_context() It's not used anymore. And in particular we do want to keep the display context private, so we're not gonna return it from this function.
2021-07-10 01:24:00 +00:00
* Used to retrieves the `GdkGLContext` that this @context share data with.
*
* As many contexts can share data now and no single shared context exists
* anymore, this function has been deprecated and now always returns %NULL.
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
*
gl: Deprecate gdk_gl_context_get_shared_context() It's not used anymore. And in particular we do want to keep the display context private, so we're not gonna return it from this function.
2021-07-10 01:24:00 +00:00
* Returns: (nullable) (transfer none): %NULL
*
* Deprecated: 4.4: Use [method@Gdk.GLContext.is_shared] to check if contexts
* can be shared.
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
*/
GdkGLContext *
gdk_gl_context_get_shared_context (GdkGLContext *context)
{
g_return_val_if_fail (GDK_IS_GL_CONTEXT (context), NULL);
gl: Deprecate gdk_gl_context_get_shared_context() It's not used anymore. And in particular we do want to keep the display context private, so we're not gonna return it from this function.
2021-07-10 01:24:00 +00:00
return NULL;
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
}
gl: Add gdk_gl_context_get_version() Store the OpenGL version when we first do the extensions check; this allows client code to check the available GL version without requiring a call to gdk_gl_context_make_current() and epoxy_gl_version().
2015-02-12 14:28:22 +00:00
/**
* gdk_gl_context_get_version:
docs: Rework the gdk docs Convert links, make things more concise.
2021-02-21 05:13:57 +00:00
* @context: a `GdkGLContext`
gl: Add gdk_gl_context_get_version() Store the OpenGL version when we first do the extensions check; this allows client code to check the available GL version without requiring a call to gdk_gl_context_make_current() and epoxy_gl_version().
2015-02-12 14:28:22 +00:00
* @major: (out): return location for the major version
* @minor: (out): return location for the minor version
*
* Retrieves the OpenGL version of the @context.
*
* The @context must be realized prior to calling this function.
*/
void
gdk_gl_context_get_version (GdkGLContext *context,
int *major,
int *minor)
{
GdkGLContextPrivate *priv = gdk_gl_context_get_instance_private (context);
g_return_if_fail (GDK_IS_GL_CONTEXT (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
g_return_if_fail (gdk_gl_context_is_realized (context));
gl: Add gdk_gl_context_get_version() Store the OpenGL version when we first do the extensions check; this allows client code to check the available GL version without requiring a call to gdk_gl_context_make_current() and epoxy_gl_version().
2015-02-12 14:28:22 +00:00
if (major != NULL)
glcontext: Use GdkGLVersion elsewhere ... and add a convenience API to generate GL versions from strings to make the gdk_gl_context_check() API nicer.
2023-04-25 17:32:12 +00:00
*major = gdk_gl_version_get_major (&priv->gl_version);
gl: Add gdk_gl_context_get_version() Store the OpenGL version when we first do the extensions check; this allows client code to check the available GL version without requiring a call to gdk_gl_context_make_current() and epoxy_gl_version().
2015-02-12 14:28:22 +00:00
if (minor != NULL)
glcontext: Use GdkGLVersion elsewhere ... and add a convenience API to generate GL versions from strings to make the gdk_gl_context_check() API nicer.
2023-04-25 17:32:12 +00:00
*minor = gdk_gl_version_get_minor (&priv->gl_version);
gl: Add gdk_gl_context_get_version() Store the OpenGL version when we first do the extensions check; this allows client code to check the available GL version without requiring a call to gdk_gl_context_make_current() and epoxy_gl_version().
2015-02-12 14:28:22 +00:00
}
glcontext: Add gdk_gl_context_get_glsl_version_string() This is in preparation for the new renderer.
2023-08-29 10:59:26 +00:00
const char *
gdk_gl_context_get_glsl_version_string (GdkGLContext *self)
{
GdkGLContextPrivate *priv = gdk_gl_context_get_instance_private (self);
if (priv->api == GDK_GL_API_GL)
{
if (gdk_gl_version_greater_equal (&priv->gl_version, &GDK_GL_VERSION_INIT (4, 6)))
return "#version 460";
else if (gdk_gl_version_greater_equal (&priv->gl_version, &GDK_GL_VERSION_INIT (4, 5)))
return "#version 450";
else if (gdk_gl_version_greater_equal (&priv->gl_version, &GDK_GL_VERSION_INIT (4, 4)))
return "#version 440";
else if (gdk_gl_version_greater_equal (&priv->gl_version, &GDK_GL_VERSION_INIT (4, 3)))
return "#version 430";
else if (gdk_gl_version_greater_equal (&priv->gl_version, &GDK_GL_VERSION_INIT (4, 2)))
return "#version 420";
else if (gdk_gl_version_greater_equal (&priv->gl_version, &GDK_GL_VERSION_INIT (4, 1)))
return "#version 410";
else if (gdk_gl_version_greater_equal (&priv->gl_version, &GDK_GL_VERSION_INIT (4, 0)))
return "#version 400";
else if (gdk_gl_version_greater_equal (&priv->gl_version, &GDK_GL_VERSION_INIT (3, 3)))
return "#version 330";
else if (gdk_gl_version_greater_equal (&priv->gl_version, &GDK_GL_VERSION_INIT (3, 2)))
return "#version 150";
else if (gdk_gl_version_greater_equal (&priv->gl_version, &GDK_GL_VERSION_INIT (3, 1)))
return "#version 140";
else
return "#version 130";
}
else if (priv->api == GDK_GL_API_GLES)
{
if (gdk_gl_version_greater_equal (&priv->gl_version, &GDK_GL_VERSION_INIT (3, 2)))
return "#version 320 es";
else if (gdk_gl_version_greater_equal (&priv->gl_version, &GDK_GL_VERSION_INIT (3, 1)))
return "#version 310 es";
else if (gdk_gl_version_greater_equal (&priv->gl_version, &GDK_GL_VERSION_INIT (3, 0)))
return "#version 300 es";
else if (gdk_gl_version_greater_equal (&priv->gl_version, &GDK_GL_VERSION_INIT (3, 0)))
return "#version 300 es";
else
return "#version 100";
}
else
{
/* must be realized to be called */
g_assert_not_reached ();
}
}
gdk: Add support for OpenGL This adds the new type GdkGLContext that wraps an OpenGL context for a particular native window. It also adds support for the gdk paint machinery to use OpenGL to draw everything. As soon as anyone creates a GL context for a native window we create a "paint context" for that GdkWindow and switch to using GL for painting it. This commit contains only an implementation for X11 (using GLX). The way painting works is that all client gl contexts draw into offscreen buffers rather than directly to the back buffer, and the way something gets onto the window is by using gdk_cairo_draw_from_gl() to draw part of that buffer onto the draw cairo context. As a fallback (if we're doing redirected drawing or some effect like a cairo_push_group()) we read back the gl buffer into memory and composite using cairo. This means that GL rendering works in all cases, including rendering to a PDF. However, this is not particularly fast. In the *typical* case, where we're drawing directly to the window in the regular paint loop we hit the fast path. The fast path uses opengl to draw the buffer to the window back buffer, either by blitting or texturing. Then we track the region that was drawn, and when the draw ends we paint the normal cairo surface to the window (using texture-from-pixmap in the X11 case, or texture from cairo image otherwise) in the regions where there is no gl painted. There are some complexities wrt layering of gl and cairo areas though: * We track via gdk_window_mark_paint_from_clip() whenever gtk is painting over a region we previously rendered with opengl (flushed_region). This area (needs_blend_region) is blended rather than copied at the end of the frame. * If we're drawing a gl texture with alpha we first copy the current cairo_surface inside the target region to the back buffer before we blend over it. These two operations allow us full stacking of transparent gl and cairo regions.
2014-10-09 08:45:44 +00:00
/**
* gdk_gl_context_clear_current:
*
docs: Rework the gdk docs Convert links, make things more concise.
2021-02-21 05:13:57 +00:00
* Clears the current `GdkGLContext`.
gdk: Add support for OpenGL This adds the new type GdkGLContext that wraps an OpenGL context for a particular native window. It also adds support for the gdk paint machinery to use OpenGL to draw everything. As soon as anyone creates a GL context for a native window we create a "paint context" for that GdkWindow and switch to using GL for painting it. This commit contains only an implementation for X11 (using GLX). The way painting works is that all client gl contexts draw into offscreen buffers rather than directly to the back buffer, and the way something gets onto the window is by using gdk_cairo_draw_from_gl() to draw part of that buffer onto the draw cairo context. As a fallback (if we're doing redirected drawing or some effect like a cairo_push_group()) we read back the gl buffer into memory and composite using cairo. This means that GL rendering works in all cases, including rendering to a PDF. However, this is not particularly fast. In the *typical* case, where we're drawing directly to the window in the regular paint loop we hit the fast path. The fast path uses opengl to draw the buffer to the window back buffer, either by blitting or texturing. Then we track the region that was drawn, and when the draw ends we paint the normal cairo surface to the window (using texture-from-pixmap in the X11 case, or texture from cairo image otherwise) in the regions where there is no gl painted. There are some complexities wrt layering of gl and cairo areas though: * We track via gdk_window_mark_paint_from_clip() whenever gtk is painting over a region we previously rendered with opengl (flushed_region). This area (needs_blend_region) is blended rather than copied at the end of the frame. * If we're drawing a gl texture with alpha we first copy the current cairo_surface inside the target region to the back buffer before we blend over it. These two operations allow us full stacking of transparent gl and cairo regions.
2014-10-09 08:45:44 +00:00
*
* Any OpenGL call after this function returns will be ignored
docs: Rework the gdk docs Convert links, make things more concise.
2021-02-21 05:13:57 +00:00
* until [method@Gdk.GLContext.make_current] is called.
gdk: Add support for OpenGL This adds the new type GdkGLContext that wraps an OpenGL context for a particular native window. It also adds support for the gdk paint machinery to use OpenGL to draw everything. As soon as anyone creates a GL context for a native window we create a "paint context" for that GdkWindow and switch to using GL for painting it. This commit contains only an implementation for X11 (using GLX). The way painting works is that all client gl contexts draw into offscreen buffers rather than directly to the back buffer, and the way something gets onto the window is by using gdk_cairo_draw_from_gl() to draw part of that buffer onto the draw cairo context. As a fallback (if we're doing redirected drawing or some effect like a cairo_push_group()) we read back the gl buffer into memory and composite using cairo. This means that GL rendering works in all cases, including rendering to a PDF. However, this is not particularly fast. In the *typical* case, where we're drawing directly to the window in the regular paint loop we hit the fast path. The fast path uses opengl to draw the buffer to the window back buffer, either by blitting or texturing. Then we track the region that was drawn, and when the draw ends we paint the normal cairo surface to the window (using texture-from-pixmap in the X11 case, or texture from cairo image otherwise) in the regions where there is no gl painted. There are some complexities wrt layering of gl and cairo areas though: * We track via gdk_window_mark_paint_from_clip() whenever gtk is painting over a region we previously rendered with opengl (flushed_region). This area (needs_blend_region) is blended rather than copied at the end of the frame. * If we're drawing a gl texture with alpha we first copy the current cairo_surface inside the target region to the back buffer before we blend over it. These two operations allow us full stacking of transparent gl and cairo regions.
2014-10-09 08:45:44 +00:00
*/
void
gdk_gl_context_clear_current (void)
{
gl: Store the context::in-frame state in the current context Do not treat the context as already current when the value of context::in-frame changes. This is so we can bind to EGL_NO_SURFACE if context::in-frame == false and to context::surface if context::in-frame == true. This allows getting rid of the attached property in future commits.
2021-07-06 02:47:15 +00:00
MaskedContext *current;
gdk: Add support for OpenGL This adds the new type GdkGLContext that wraps an OpenGL context for a particular native window. It also adds support for the gdk paint machinery to use OpenGL to draw everything. As soon as anyone creates a GL context for a native window we create a "paint context" for that GdkWindow and switch to using GL for painting it. This commit contains only an implementation for X11 (using GLX). The way painting works is that all client gl contexts draw into offscreen buffers rather than directly to the back buffer, and the way something gets onto the window is by using gdk_cairo_draw_from_gl() to draw part of that buffer onto the draw cairo context. As a fallback (if we're doing redirected drawing or some effect like a cairo_push_group()) we read back the gl buffer into memory and composite using cairo. This means that GL rendering works in all cases, including rendering to a PDF. However, this is not particularly fast. In the *typical* case, where we're drawing directly to the window in the regular paint loop we hit the fast path. The fast path uses opengl to draw the buffer to the window back buffer, either by blitting or texturing. Then we track the region that was drawn, and when the draw ends we paint the normal cairo surface to the window (using texture-from-pixmap in the X11 case, or texture from cairo image otherwise) in the regions where there is no gl painted. There are some complexities wrt layering of gl and cairo areas though: * We track via gdk_window_mark_paint_from_clip() whenever gtk is painting over a region we previously rendered with opengl (flushed_region). This area (needs_blend_region) is blended rather than copied at the end of the frame. * If we're drawing a gl texture with alpha we first copy the current cairo_surface inside the target region to the back buffer before we blend over it. These two operations allow us full stacking of transparent gl and cairo regions.
2014-10-09 08:45:44 +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
current = g_private_get (&thread_current_context);
if (current != NULL)
{
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
GdkGLContext *context = unmask_context (current);
if (GDK_GL_CONTEXT_GET_CLASS (context)->clear_current (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
g_private_replace (&thread_current_context, NULL);
}
gdk: Add support for OpenGL This adds the new type GdkGLContext that wraps an OpenGL context for a particular native window. It also adds support for the gdk paint machinery to use OpenGL to draw everything. As soon as anyone creates a GL context for a native window we create a "paint context" for that GdkWindow and switch to using GL for painting it. This commit contains only an implementation for X11 (using GLX). The way painting works is that all client gl contexts draw into offscreen buffers rather than directly to the back buffer, and the way something gets onto the window is by using gdk_cairo_draw_from_gl() to draw part of that buffer onto the draw cairo context. As a fallback (if we're doing redirected drawing or some effect like a cairo_push_group()) we read back the gl buffer into memory and composite using cairo. This means that GL rendering works in all cases, including rendering to a PDF. However, this is not particularly fast. In the *typical* case, where we're drawing directly to the window in the regular paint loop we hit the fast path. The fast path uses opengl to draw the buffer to the window back buffer, either by blitting or texturing. Then we track the region that was drawn, and when the draw ends we paint the normal cairo surface to the window (using texture-from-pixmap in the X11 case, or texture from cairo image otherwise) in the regions where there is no gl painted. There are some complexities wrt layering of gl and cairo areas though: * We track via gdk_window_mark_paint_from_clip() whenever gtk is painting over a region we previously rendered with opengl (flushed_region). This area (needs_blend_region) is blended rather than copied at the end of the frame. * If we're drawing a gl texture with alpha we first copy the current cairo_surface inside the target region to the back buffer before we blend over it. These two operations allow us full stacking of transparent gl and cairo regions.
2014-10-09 08:45:44 +00:00
}
gl: Clear current when destroying current's surface When destroying the EGLSurface or GLXDrawable of a GdkSurface, make sure the current context is not still bound to it. If it is, clear the current context. Fixes #4554
2021-12-22 18:49:13 +00:00
/*<private>
* gdk_gl_context_clear_current_if_surface:
* @surface: surface to clear for
*
* Does a gdk_gl_context_clear_current() if the current context is attached
* to @surface, leaves the current context alone otherwise.
**/
void
gdk_gl_context_clear_current_if_surface (GdkSurface *surface)
{
MaskedContext *current;
current = g_private_get (&thread_current_context);
if (current != NULL && !mask_is_surfaceless (current))
{
GdkGLContext *context = unmask_context (current);
if (gdk_gl_context_get_surface (context) != surface)
return;
if (GDK_GL_CONTEXT_GET_CLASS (context)->clear_current (context))
g_private_replace (&thread_current_context, NULL);
}
}
gdk: Add support for OpenGL This adds the new type GdkGLContext that wraps an OpenGL context for a particular native window. It also adds support for the gdk paint machinery to use OpenGL to draw everything. As soon as anyone creates a GL context for a native window we create a "paint context" for that GdkWindow and switch to using GL for painting it. This commit contains only an implementation for X11 (using GLX). The way painting works is that all client gl contexts draw into offscreen buffers rather than directly to the back buffer, and the way something gets onto the window is by using gdk_cairo_draw_from_gl() to draw part of that buffer onto the draw cairo context. As a fallback (if we're doing redirected drawing or some effect like a cairo_push_group()) we read back the gl buffer into memory and composite using cairo. This means that GL rendering works in all cases, including rendering to a PDF. However, this is not particularly fast. In the *typical* case, where we're drawing directly to the window in the regular paint loop we hit the fast path. The fast path uses opengl to draw the buffer to the window back buffer, either by blitting or texturing. Then we track the region that was drawn, and when the draw ends we paint the normal cairo surface to the window (using texture-from-pixmap in the X11 case, or texture from cairo image otherwise) in the regions where there is no gl painted. There are some complexities wrt layering of gl and cairo areas though: * We track via gdk_window_mark_paint_from_clip() whenever gtk is painting over a region we previously rendered with opengl (flushed_region). This area (needs_blend_region) is blended rather than copied at the end of the frame. * If we're drawing a gl texture with alpha we first copy the current cairo_surface inside the target region to the back buffer before we blend over it. These two operations allow us full stacking of transparent gl and cairo regions.
2014-10-09 08:45:44 +00:00
/**
* gdk_gl_context_get_current:
*
docs: Rework the gdk docs Convert links, make things more concise.
2021-02-21 05:13:57 +00:00
* Retrieves the current `GdkGLContext`.
gdk: Add support for OpenGL This adds the new type GdkGLContext that wraps an OpenGL context for a particular native window. It also adds support for the gdk paint machinery to use OpenGL to draw everything. As soon as anyone creates a GL context for a native window we create a "paint context" for that GdkWindow and switch to using GL for painting it. This commit contains only an implementation for X11 (using GLX). The way painting works is that all client gl contexts draw into offscreen buffers rather than directly to the back buffer, and the way something gets onto the window is by using gdk_cairo_draw_from_gl() to draw part of that buffer onto the draw cairo context. As a fallback (if we're doing redirected drawing or some effect like a cairo_push_group()) we read back the gl buffer into memory and composite using cairo. This means that GL rendering works in all cases, including rendering to a PDF. However, this is not particularly fast. In the *typical* case, where we're drawing directly to the window in the regular paint loop we hit the fast path. The fast path uses opengl to draw the buffer to the window back buffer, either by blitting or texturing. Then we track the region that was drawn, and when the draw ends we paint the normal cairo surface to the window (using texture-from-pixmap in the X11 case, or texture from cairo image otherwise) in the regions where there is no gl painted. There are some complexities wrt layering of gl and cairo areas though: * We track via gdk_window_mark_paint_from_clip() whenever gtk is painting over a region we previously rendered with opengl (flushed_region). This area (needs_blend_region) is blended rather than copied at the end of the frame. * If we're drawing a gl texture with alpha we first copy the current cairo_surface inside the target region to the back buffer before we blend over it. These two operations allow us full stacking of transparent gl and cairo regions.
2014-10-09 08:45:44 +00:00
*
docs: Reduce redundancy Remove a boatload of "or %NULL" from nullable parameters and return values. gi-docgen generates suitable text from the annotation that we don't need to duplicate. This adds a few missing nullable annotations too.
2021-05-21 00:45:06 +00:00
* Returns: (nullable) (transfer none): the current `GdkGLContext`
gdk: Add support for OpenGL This adds the new type GdkGLContext that wraps an OpenGL context for a particular native window. It also adds support for the gdk paint machinery to use OpenGL to draw everything. As soon as anyone creates a GL context for a native window we create a "paint context" for that GdkWindow and switch to using GL for painting it. This commit contains only an implementation for X11 (using GLX). The way painting works is that all client gl contexts draw into offscreen buffers rather than directly to the back buffer, and the way something gets onto the window is by using gdk_cairo_draw_from_gl() to draw part of that buffer onto the draw cairo context. As a fallback (if we're doing redirected drawing or some effect like a cairo_push_group()) we read back the gl buffer into memory and composite using cairo. This means that GL rendering works in all cases, including rendering to a PDF. However, this is not particularly fast. In the *typical* case, where we're drawing directly to the window in the regular paint loop we hit the fast path. The fast path uses opengl to draw the buffer to the window back buffer, either by blitting or texturing. Then we track the region that was drawn, and when the draw ends we paint the normal cairo surface to the window (using texture-from-pixmap in the X11 case, or texture from cairo image otherwise) in the regions where there is no gl painted. There are some complexities wrt layering of gl and cairo areas though: * We track via gdk_window_mark_paint_from_clip() whenever gtk is painting over a region we previously rendered with opengl (flushed_region). This area (needs_blend_region) is blended rather than copied at the end of the frame. * If we're drawing a gl texture with alpha we first copy the current cairo_surface inside the target region to the back buffer before we blend over it. These two operations allow us full stacking of transparent gl and cairo regions.
2014-10-09 08:45:44 +00:00
*/
GdkGLContext *
gdk_gl_context_get_current (void)
{
gl: Store the context::in-frame state in the current context Do not treat the context as already current when the value of context::in-frame changes. This is so we can bind to EGL_NO_SURFACE if context::in-frame == false and to context::surface if context::in-frame == true. This allows getting rid of the attached property in future commits.
2021-07-06 02:47:15 +00:00
MaskedContext *current;
gdk: Add private GLContext::is_current() check ... and use this check in gdk_gl_context_make_current() and gdk_gl_context_get_current() to make sure the context really is still current. The context no longer being current can happen when external GL implementations make their own contexts current in the same threads GDK contexts are used in. And that can happen for example by WebKit. Theoretically, this should also allow external EGL code to run in X11 applications when GDK chooses to use GLX, but I didn't try it. Fixes #5392
2023-02-02 01:49:56 +00:00
GdkGLContext *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
current = g_private_get (&thread_current_context);
gdk: Add private GLContext::is_current() check ... and use this check in gdk_gl_context_make_current() and gdk_gl_context_get_current() to make sure the context really is still current. The context no longer being current can happen when external GL implementations make their own contexts current in the same threads GDK contexts are used in. And that can happen for example by WebKit. Theoretically, this should also allow external EGL code to run in X11 applications when GDK chooses to use GLX, but I didn't try it. Fixes #5392
2023-02-02 01:49:56 +00:00
context = unmask_context (current);
if (context && !gdk_gl_context_check_is_current (context))
{
g_private_replace (&thread_current_context, NULL);
context = NULL;
}
gdk: Add support for OpenGL This adds the new type GdkGLContext that wraps an OpenGL context for a particular native window. It also adds support for the gdk paint machinery to use OpenGL to draw everything. As soon as anyone creates a GL context for a native window we create a "paint context" for that GdkWindow and switch to using GL for painting it. This commit contains only an implementation for X11 (using GLX). The way painting works is that all client gl contexts draw into offscreen buffers rather than directly to the back buffer, and the way something gets onto the window is by using gdk_cairo_draw_from_gl() to draw part of that buffer onto the draw cairo context. As a fallback (if we're doing redirected drawing or some effect like a cairo_push_group()) we read back the gl buffer into memory and composite using cairo. This means that GL rendering works in all cases, including rendering to a PDF. However, this is not particularly fast. In the *typical* case, where we're drawing directly to the window in the regular paint loop we hit the fast path. The fast path uses opengl to draw the buffer to the window back buffer, either by blitting or texturing. Then we track the region that was drawn, and when the draw ends we paint the normal cairo surface to the window (using texture-from-pixmap in the X11 case, or texture from cairo image otherwise) in the regions where there is no gl painted. There are some complexities wrt layering of gl and cairo areas though: * We track via gdk_window_mark_paint_from_clip() whenever gtk is painting over a region we previously rendered with opengl (flushed_region). This area (needs_blend_region) is blended rather than copied at the end of the frame. * If we're drawing a gl texture with alpha we first copy the current cairo_surface inside the target region to the back buffer before we blend over it. These two operations allow us full stacking of transparent gl and cairo regions.
2014-10-09 08:45:44 +00:00
gdk: Add private GLContext::is_current() check ... and use this check in gdk_gl_context_make_current() and gdk_gl_context_get_current() to make sure the context really is still current. The context no longer being current can happen when external GL implementations make their own contexts current in the same threads GDK contexts are used in. And that can happen for example by WebKit. Theoretically, this should also allow external EGL code to run in X11 applications when GDK chooses to use GLX, but I didn't try it. Fixes #5392
2023-02-02 01:49:56 +00:00
return context;
gdk: Add support for OpenGL This adds the new type GdkGLContext that wraps an OpenGL context for a particular native window. It also adds support for the gdk paint machinery to use OpenGL to draw everything. As soon as anyone creates a GL context for a native window we create a "paint context" for that GdkWindow and switch to using GL for painting it. This commit contains only an implementation for X11 (using GLX). The way painting works is that all client gl contexts draw into offscreen buffers rather than directly to the back buffer, and the way something gets onto the window is by using gdk_cairo_draw_from_gl() to draw part of that buffer onto the draw cairo context. As a fallback (if we're doing redirected drawing or some effect like a cairo_push_group()) we read back the gl buffer into memory and composite using cairo. This means that GL rendering works in all cases, including rendering to a PDF. However, this is not particularly fast. In the *typical* case, where we're drawing directly to the window in the regular paint loop we hit the fast path. The fast path uses opengl to draw the buffer to the window back buffer, either by blitting or texturing. Then we track the region that was drawn, and when the draw ends we paint the normal cairo surface to the window (using texture-from-pixmap in the X11 case, or texture from cairo image otherwise) in the regions where there is no gl painted. There are some complexities wrt layering of gl and cairo areas though: * We track via gdk_window_mark_paint_from_clip() whenever gtk is painting over a region we previously rendered with opengl (flushed_region). This area (needs_blend_region) is blended rather than copied at the end of the frame. * If we're drawing a gl texture with alpha we first copy the current cairo_surface inside the target region to the back buffer before we blend over it. These two operations allow us full stacking of transparent gl and cairo regions.
2014-10-09 08:45:44 +00:00
}
gl: Add a gdk_gl_context_has_debug accessor Check if the label_object_ etc. functions are gonna do anything at all. The g_type_name_from_instance calls keep poppoing up in profiles.
2020-07-24 16:54:23 +00:00
glcontext: Add gdk_gl_context_get_memory_flags() Checks which features of a given memory format are supported by the current GL implementation. We check: * usable: Can be used as a texture with NEAREST filter * renderable: Can be used as a render target * filterable: Can be used with GL_LINEAR In normal GL, all formats are all of these things, but GLES is a lot more picky. So far nobody uses this.
2023-12-07 04:45:59 +00:00
GdkGLMemoryFlags
gdk_gl_context_get_format_flags (GdkGLContext *self,
GdkMemoryFormat format)
{
GdkGLContextPrivate *priv = gdk_gl_context_get_instance_private (self);
return priv->memory_flags[format];
}
gl: Add a gdk_gl_context_has_debug accessor Check if the label_object_ etc. functions are gonna do anything at all. The g_type_name_from_instance calls keep poppoing up in profiles.
2020-07-24 16:54:23 +00:00
gboolean
gdk_gl_context_has_debug (GdkGLContext *self)
{
GdkGLContextPrivate *priv = gdk_gl_context_get_instance_private (self);
return priv->debug_enabled || priv->use_khr_debug;
}
OpenGL/ES: Fix 'R' and 'B' bits inverted on Windows We need to use GL_BGRA instead of GL_RGBA when doing glReadPixels() on EGL on Windows (ANGLE) so that the red and blue bits won't be displayed inverted. Also fix the logic where we determine whether to bit blit or redraw everything.
2018-07-31 10:18:59 +00:00
gdk: Check OES_vertex_half_float GLES extension This will be checked in the GL renderer.
2022-05-05 17:08:32 +00:00
gboolean
gdk_gl_context_has_vertex_half_float (GdkGLContext *self)
{
GdkGLContextPrivate *priv = gdk_gl_context_get_instance_private (self);
return priv->has_half_float;
}
glcontext: Add a way to check for GLsync
2023-04-26 09:59:51 +00:00
gboolean
gdk_gl_context_has_sync (GdkGLContext *self)
{
GdkGLContextPrivate *priv = gdk_gl_context_get_instance_private (self);
return priv->has_sync;
}
glcontext: Add api to check for vertex arrays Vertex arrays are available in GL and in GLES >= 3. We don't check for the GLES extension that provided vertex arrays in older GLES, since that requires using different API. This api avoids version checks all over the place.
2023-10-20 00:56:59 +00:00
/* Return if glGenVertexArrays, glBindVertexArray and glDeleteVertexArrays
* can be used
*/
gboolean
gdk_gl_context_has_vertex_arrays (GdkGLContext *self)
{
GdkGLContextPrivate *priv = gdk_gl_context_get_instance_private (self);
switch (priv->api)
{
case GDK_GL_API_GL:
return TRUE;
case GDK_GL_API_GLES:
return gdk_gl_version_get_major (&priv->gl_version) >= 3;
default:
g_return_val_if_reached (FALSE);
}
}
OpenGL/ES: Fix 'R' and 'B' bits inverted on Windows We need to use GL_BGRA instead of GL_RGBA when doing glReadPixels() on EGL on Windows (ANGLE) so that the red and blue bits won't be displayed inverted. Also fix the logic where we determine whether to bit blit or redraw everything.
2018-07-31 10:18:59 +00:00
/* This is currently private! */
/* When using GL/ES, don't flip the 'R' and 'B' bits on Windows/ANGLE for glReadPixels() */
gboolean
gdk_gl_context_use_es_bgra (GdkGLContext *context)
{
if (!gdk_gl_context_get_use_es (context))
return FALSE;
#ifdef GDK_WINDOWING_WIN32
if (GDK_WIN32_IS_GL_CONTEXT (context))
return TRUE;
#endif
return FALSE;
}
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
static GdkGLBackend the_gl_backend_type = GDK_GL_NONE;
static const char *gl_backend_names[] = {
[GDK_GL_NONE] = "No GL (You should never read this)",
[GDK_GL_EGL] = "EGL",
[GDK_GL_GLX] = "X11 GLX",
[GDK_GL_WGL] = "Windows WGL",
[GDK_GL_CGL] = "Apple CGL"
};
/*<private>
* gdk_gl_backend_can_be_used:
* @backend_type: Type of backend to check
* @error: Return location for an error
*
* Checks if this backend type can be used. When multiple displays
* are opened that use different GL backends, conflicts can arise,
* so this function checks that all displays use compatible GL
* backends.
*
* Returns: %TRUE if the backend can still be used
*/
gboolean
gdk_gl_backend_can_be_used (GdkGLBackend backend_type,
GError **error)
{
gdk: Check OES_vertex_half_float GLES extension This will be checked in the GL renderer.
2022-05-05 17:08:32 +00:00
if (the_gl_backend_type == GDK_GL_NONE ||
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
the_gl_backend_type == backend_type)
return TRUE;
g_set_error (error, GDK_GL_ERROR, GDK_GL_ERROR_NOT_AVAILABLE,
/* translators: This is about OpenGL backend names, like
* "Trying to use X11 GLX, but EGL is already in use" */
_("Trying to use %s, but %s is already in use"),
gl_backend_names[backend_type],
gl_backend_names[the_gl_backend_type]);
return FALSE;
}
/*<private>
* gdk_gl_backend_use:
* @backend_type: Type of backend
*
* Ensures that the backend in use is the given one. If another backend
* is already in use, this function will abort the program. It should
* have previously checked via gdk_gl_backend_can_be_used().
**/
void
gdk_gl_backend_use (GdkGLBackend backend_type)
{
/* Check that the context class is properly initializing its backend type */
g_assert (backend_type != GDK_GL_NONE);
if (the_gl_backend_type == GDK_GL_NONE)
{
the_gl_backend_type = backend_type;
/* This is important!!!11eleven
* (But really: How do I print a message in 2 categories?) */
gdk: Use the new debug macros
2022-09-23 00:48:58 +00:00
GDK_DEBUG (OPENGL, "Using OpenGL backend %s", gl_backend_names[the_gl_backend_type]);
GDK_DEBUG (MISC, "Using OpenGL backend %s", gl_backend_names[the_gl_backend_type]);
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
}
g_assert (the_gl_backend_type == backend_type);
}
gl context: Add private dmabuf API Add API to import a dmabuf into a texture, and to export a texture to a dmabuf. All this is implemented using the relevant EGL and GL extensions.
2023-10-15 23:27:22 +00:00
dmabuf: Modify gdk_gl_context_import_dmabuf() Move a bunch of code - namely the target selection - into the function. I want to use the same code in the NGL renderer, so no need to duplicate it.
2023-11-02 01:51:41 +00:00
static guint
gdk_gl_context_import_dmabuf_for_target (GdkGLContext *self,
int width,
int height,
const GdkDmabuf *dmabuf,
int target)
gl context: Add private dmabuf API Add API to import a dmabuf into a texture, and to export a texture to a dmabuf. All this is implemented using the relevant EGL and GL extensions.
2023-10-15 23:27:22 +00:00
{
#if defined(HAVE_EGL) && defined(HAVE_DMABUF)
GdkDisplay *display = gdk_gl_context_get_display (self);
EGLImage image;
guint texture_id;
egl: Split out a function This makes no sense by itself, but we want to create the EGLImage at DmabufTexture construction so that we can actually reject dmabufs that we can't create EGLImages for. This will make it possible to bail when the stride limitation for AMD GPUs hits.
2023-12-17 08:56:42 +00:00
image = gdk_dmabuf_egl_create_image (display,
width,
height,
dmabuf,
target);
gl context: Add private dmabuf API Add API to import a dmabuf into a texture, and to export a texture to a dmabuf. All this is implemented using the relevant EGL and GL extensions.
2023-10-15 23:27:22 +00:00
if (image == EGL_NO_IMAGE)
egl: Split out a function This makes no sense by itself, but we want to create the EGLImage at DmabufTexture construction so that we can actually reject dmabufs that we can't create EGLImages for. This will make it possible to bail when the stride limitation for AMD GPUs hits.
2023-12-17 08:56:42 +00:00
return 0;
gl context: Add private dmabuf API Add API to import a dmabuf into a texture, and to export a texture to a dmabuf. All this is implemented using the relevant EGL and GL extensions.
2023-10-15 23:27:22 +00:00
glGenTextures (1, &texture_id);
glBindTexture (target, texture_id);
glEGLImageTargetTexture2DOES (target, image);
glTexParameteri (target, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
glTexParameteri (target, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
egl: Split out a function This makes no sense by itself, but we want to create the EGLImage at DmabufTexture construction so that we can actually reject dmabufs that we can't create EGLImages for. This will make it possible to bail when the stride limitation for AMD GPUs hits.
2023-12-17 08:56:42 +00:00
eglDestroyImageKHR (gdk_display_get_egl_display (display), image);
gl context: Add private dmabuf API Add API to import a dmabuf into a texture, and to export a texture to a dmabuf. All this is implemented using the relevant EGL and GL extensions.
2023-10-15 23:27:22 +00:00
return texture_id;
#else
return 0;
#endif
}
dmabuf: Modify gdk_gl_context_import_dmabuf() Move a bunch of code - namely the target selection - into the function. I want to use the same code in the NGL renderer, so no need to duplicate it.
2023-11-02 01:51:41 +00:00
guint
gdk_gl_context_import_dmabuf (GdkGLContext *self,
int width,
int height,
const GdkDmabuf *dmabuf,
gboolean *external)
{
GdkDisplay *display = gdk_gl_context_get_display (self);
guint texture_id;
gdk_display_init_dmabuf (display);
if (!gdk_dmabuf_formats_contains (display->egl_external_formats, dmabuf->fourcc, dmabuf->modifier))
{
texture_id = gdk_gl_context_import_dmabuf_for_target (self,
width, height,
dmabuf,
GL_TEXTURE_2D);
if (texture_id == 0)
{
dmabuf: Improve consistency of debug messages Make sure all our dmabuf debug messages are display-scoped so the inspector doesn't trigger them, use the same formatting throughout, and improve consistency of wording here and there.
2023-11-12 11:05:35 +00:00
GDK_DISPLAY_DEBUG (display, DMABUF,
"Import of %dx%d %.4s:%#" G_GINT64_MODIFIER "x dmabuf failed",
dmabuf: Modify gdk_gl_context_import_dmabuf() Move a bunch of code - namely the target selection - into the function. I want to use the same code in the NGL renderer, so no need to duplicate it.
2023-11-02 01:51:41 +00:00
width, height,
dmabuf: Improve consistency of debug messages Make sure all our dmabuf debug messages are display-scoped so the inspector doesn't trigger them, use the same formatting throughout, and improve consistency of wording here and there.
2023-11-12 11:05:35 +00:00
(char *) &dmabuf->fourcc, dmabuf->modifier);
dmabuf: Modify gdk_gl_context_import_dmabuf() Move a bunch of code - namely the target selection - into the function. I want to use the same code in the NGL renderer, so no need to duplicate it.
2023-11-02 01:51:41 +00:00
return 0;
}
dmabuf: Improve consistency of debug messages Make sure all our dmabuf debug messages are display-scoped so the inspector doesn't trigger them, use the same formatting throughout, and improve consistency of wording here and there.
2023-11-12 11:05:35 +00:00
GDK_DISPLAY_DEBUG (display, DMABUF,
"Imported %dx%d %.4s:%#" G_GINT64_MODIFIER "x dmabuf as GL_TEXTURE_2D texture",
dmabuf: Modify gdk_gl_context_import_dmabuf() Move a bunch of code - namely the target selection - into the function. I want to use the same code in the NGL renderer, so no need to duplicate it.
2023-11-02 01:51:41 +00:00
width, height,
dmabuf: Improve consistency of debug messages Make sure all our dmabuf debug messages are display-scoped so the inspector doesn't trigger them, use the same formatting throughout, and improve consistency of wording here and there.
2023-11-12 11:05:35 +00:00
(char *) &dmabuf->fourcc, dmabuf->modifier);
dmabuf: Modify gdk_gl_context_import_dmabuf() Move a bunch of code - namely the target selection - into the function. I want to use the same code in the NGL renderer, so no need to duplicate it.
2023-11-02 01:51:41 +00:00
*external = FALSE;
return texture_id;
}
if (!gdk_gl_context_get_use_es (self))
{
dmabuf: Improve consistency of debug messages Make sure all our dmabuf debug messages are display-scoped so the inspector doesn't trigger them, use the same formatting throughout, and improve consistency of wording here and there.
2023-11-12 11:05:35 +00:00
GDK_DISPLAY_DEBUG (display, DMABUF,
"Can't import external_only %.4s:%#" G_GINT64_MODIFIER "x outside of GLES",
(char *) &dmabuf->fourcc, dmabuf->modifier);
dmabuf: Modify gdk_gl_context_import_dmabuf() Move a bunch of code - namely the target selection - into the function. I want to use the same code in the NGL renderer, so no need to duplicate it.
2023-11-02 01:51:41 +00:00
return 0;
}
texture_id = gdk_gl_context_import_dmabuf_for_target (self,
width, height,
dmabuf,
GL_TEXTURE_EXTERNAL_OES);
if (texture_id == 0)
{
dmabuf: Improve consistency of debug messages Make sure all our dmabuf debug messages are display-scoped so the inspector doesn't trigger them, use the same formatting throughout, and improve consistency of wording here and there.
2023-11-12 11:05:35 +00:00
GDK_DISPLAY_DEBUG (display, DMABUF,
"Import of external_only %dx%d %.4s:%#" G_GINT64_MODIFIER "x dmabuf failed",
dmabuf: Modify gdk_gl_context_import_dmabuf() Move a bunch of code - namely the target selection - into the function. I want to use the same code in the NGL renderer, so no need to duplicate it.
2023-11-02 01:51:41 +00:00
width, height,
dmabuf: Improve consistency of debug messages Make sure all our dmabuf debug messages are display-scoped so the inspector doesn't trigger them, use the same formatting throughout, and improve consistency of wording here and there.
2023-11-12 11:05:35 +00:00
(char *) &dmabuf->fourcc, dmabuf->modifier);
dmabuf: Modify gdk_gl_context_import_dmabuf() Move a bunch of code - namely the target selection - into the function. I want to use the same code in the NGL renderer, so no need to duplicate it.
2023-11-02 01:51:41 +00:00
return 0;
}
dmabuf: Improve consistency of debug messages Make sure all our dmabuf debug messages are display-scoped so the inspector doesn't trigger them, use the same formatting throughout, and improve consistency of wording here and there.
2023-11-12 11:05:35 +00:00
GDK_DISPLAY_DEBUG (display, DMABUF,
"Imported %dx%d %.4s:%#" G_GINT64_MODIFIER "x dmabuf as GL_TEXTURE_EXTERNAL_OES texture",
dmabuf: Modify gdk_gl_context_import_dmabuf() Move a bunch of code - namely the target selection - into the function. I want to use the same code in the NGL renderer, so no need to duplicate it.
2023-11-02 01:51:41 +00:00
width, height,
dmabuf: Improve consistency of debug messages Make sure all our dmabuf debug messages are display-scoped so the inspector doesn't trigger them, use the same formatting throughout, and improve consistency of wording here and there.
2023-11-12 11:05:35 +00:00
(char *) &dmabuf->fourcc, dmabuf->modifier);
dmabuf: Modify gdk_gl_context_import_dmabuf() Move a bunch of code - namely the target selection - into the function. I want to use the same code in the NGL renderer, so no need to duplicate it.
2023-11-02 01:51:41 +00:00
*external = TRUE;
return texture_id;
}
gl context: Add private dmabuf API Add API to import a dmabuf into a texture, and to export a texture to a dmabuf. All this is implemented using the relevant EGL and GL extensions.
2023-10-15 23:27:22 +00:00
gboolean
gdk_gl_context_export_dmabuf (GdkGLContext *self,
unsigned int texture_id,
GdkDmabuf *dmabuf)
{
#if defined(HAVE_EGL) && defined(HAVE_DMABUF)
GdkGLContextPrivate *priv = gdk_gl_context_get_instance_private (self);
GdkDisplay *display = gdk_gl_context_get_display (self);
EGLDisplay egl_display = gdk_display_get_egl_display (display);
EGLContext egl_context = priv->egl_context;
EGLint attribs[10];
EGLImage image;
gboolean result = FALSE;
int i;
int fourcc;
int n_planes;
guint64 modifier;
int fds[GDK_DMABUF_MAX_PLANES];
int strides[GDK_DMABUF_MAX_PLANES];
int offsets[GDK_DMABUF_MAX_PLANES];
g_return_val_if_fail (GDK_IS_GL_CONTEXT (self), FALSE);
g_return_val_if_fail (texture_id > 0, FALSE);
g_return_val_if_fail (dmabuf != NULL, FALSE);
if (egl_display == EGL_NO_DISPLAY || !display->have_egl_dma_buf_export)
dmabuf: Improve consistency of debug messages Make sure all our dmabuf debug messages are display-scoped so the inspector doesn't trigger them, use the same formatting throughout, and improve consistency of wording here and there.
2023-11-12 11:05:35 +00:00
{
GDK_DISPLAY_DEBUG (display, DMABUF,
"Can't export dmabufs from GL, missing EGL or EGL_EXT_image_dma_buf_export");
return 0;
}
gl context: Add private dmabuf API Add API to import a dmabuf into a texture, and to export a texture to a dmabuf. All this is implemented using the relevant EGL and GL extensions.
2023-10-15 23:27:22 +00:00
dmabuf: Improve consistency of debug messages Make sure all our dmabuf debug messages are display-scoped so the inspector doesn't trigger them, use the same formatting throughout, and improve consistency of wording here and there.
2023-11-12 11:05:35 +00:00
GDK_DISPLAY_DEBUG (display, DMABUF, "Exporting GL texture to dmabuf");
gl context: Add private dmabuf API Add API to import a dmabuf into a texture, and to export a texture to a dmabuf. All this is implemented using the relevant EGL and GL extensions.
2023-10-15 23:27:22 +00:00
i = 0;
attribs[i++] = EGL_IMAGE_PRESERVED_KHR;
attribs[i++] = EGL_TRUE;
attribs[i++] = EGL_NONE;
image = eglCreateImageKHR (egl_display,
egl_context,
EGL_GL_TEXTURE_2D_KHR,
(EGLClientBuffer)GUINT_TO_POINTER (texture_id),
attribs);
if (image == EGL_NO_IMAGE)
{
dmabuf: Improve consistency of debug messages Make sure all our dmabuf debug messages are display-scoped so the inspector doesn't trigger them, use the same formatting throughout, and improve consistency of wording here and there.
2023-11-12 11:05:35 +00:00
GDK_DISPLAY_DEBUG (display, DMABUF,
"Creating EGLImage for dmabuf failed: %#x", eglGetError ());
gl context: Add private dmabuf API Add API to import a dmabuf into a texture, and to export a texture to a dmabuf. All this is implemented using the relevant EGL and GL extensions.
2023-10-15 23:27:22 +00:00
return FALSE;
}
if (!eglExportDMABUFImageQueryMESA (egl_display,
image,
&fourcc,
&n_planes,
&modifier))
{
dmabuf: Improve consistency of debug messages Make sure all our dmabuf debug messages are display-scoped so the inspector doesn't trigger them, use the same formatting throughout, and improve consistency of wording here and there.
2023-11-12 11:05:35 +00:00
GDK_DISPLAY_DEBUG (display, DMABUF,
"eglExportDMABUFImageQueryMESA failed: %#x", eglGetError ());
gl context: Add private dmabuf API Add API to import a dmabuf into a texture, and to export a texture to a dmabuf. All this is implemented using the relevant EGL and GL extensions.
2023-10-15 23:27:22 +00:00
goto out;
}
if (n_planes < 1 || n_planes > GDK_DMABUF_MAX_PLANES)
{
dmabuf: Improve consistency of debug messages Make sure all our dmabuf debug messages are display-scoped so the inspector doesn't trigger them, use the same formatting throughout, and improve consistency of wording here and there.
2023-11-12 11:05:35 +00:00
GDK_DISPLAY_DEBUG (display, DMABUF,
"dmabufs with %d planes are not supported", n_planes);
gl context: Add private dmabuf API Add API to import a dmabuf into a texture, and to export a texture to a dmabuf. All this is implemented using the relevant EGL and GL extensions.
2023-10-15 23:27:22 +00:00
goto out;
}
if (!eglExportDMABUFImageMESA (egl_display,
image,
fds,
strides,
offsets))
{
g_warning ("eglExportDMABUFImage failed: %#x", eglGetError ());
goto out;
}
for (i = 0; i < n_planes; i++)
{
if (fds[i] == -1)
{
g_warning ("dmabuf plane %d has no file descriptor", i);
goto out;
}
}
dmabuf->fourcc = (guint32)fourcc;
dmabuf->modifier = modifier;
dmabuf->n_planes = n_planes;
for (i = 0; i < n_planes; i++)
{
dmabuf->planes[i].fd = fds[i];
dmabuf->planes[i].stride = (int) strides[i];
dmabuf->planes[i].offset = (int) offsets[i];
}
dmabuf: Improve consistency of debug messages Make sure all our dmabuf debug messages are display-scoped so the inspector doesn't trigger them, use the same formatting throughout, and improve consistency of wording here and there.
2023-11-12 11:05:35 +00:00
GDK_DISPLAY_DEBUG (display, DMABUF,
"Exported GL texture to dmabuf (format: %.4s:%#" G_GINT64_MODIFIER "x, planes: %d)",
gl context: Add private dmabuf API Add API to import a dmabuf into a texture, and to export a texture to a dmabuf. All this is implemented using the relevant EGL and GL extensions.
2023-10-15 23:27:22 +00:00
(char *)&fourcc, modifier, n_planes);
result = TRUE;
out:
eglDestroyImageKHR (egl_display, image);
return result;
#else
return FALSE;
#endif
}
Reference in New Issue Copy Permalink