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
b154c9caf4
gtk/gsk/gskrenderer.c

828 lines
23 KiB
C
Raw Normal View History

Initial implementation of GSK rendering pipeline GSK is conceptually split into two scene graphs: * a simple rendering tree of operations * a complex set of logical layers The latter is built on the former, and adds convenience and high level API for application developers. The lower layer, though, is what gets transformed into the rendering pipeline, as it's simple and thus can be transformed into appropriate rendering commands with minimal state changes. The lower layer is also suitable for reuse from more complex higher layers, like the CSS machinery in GTK, without necessarily port those layers to the GSK high level API. This lower layer is based on GskRenderNode instances, which represent the tree of rendering operations; and a GskRenderer instance, which takes the render nodes and submits them (after potentially reordering and transforming them to a more appropriate representation) to the underlying graphic system.
2016-03-17 13:48:19 +00:00
/* GSK - The GTK Scene Kit
* Copyright 2016 Endless
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser 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
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library. If not, see <http://www.gnu.org/licenses/>.
*/
/**
gskrenderer: Add property annotations Connect properties, getters, and setters with annotations
2021-02-25 11:59:41 +00:00
* GskRenderer:
Initial implementation of GSK rendering pipeline GSK is conceptually split into two scene graphs: * a simple rendering tree of operations * a complex set of logical layers The latter is built on the former, and adds convenience and high level API for application developers. The lower layer, though, is what gets transformed into the rendering pipeline, as it's simple and thus can be transformed into appropriate rendering commands with minimal state changes. The lower layer is also suitable for reuse from more complex higher layers, like the CSS machinery in GTK, without necessarily port those layers to the GSK high level API. This lower layer is based on GskRenderNode instances, which represent the tree of rendering operations; and a GskRenderer instance, which takes the render nodes and submits them (after potentially reordering and transforming them to a more appropriate representation) to the underlying graphic system.
2016-03-17 13:48:19 +00:00
*
gskrenderer: Add property annotations Connect properties, getters, and setters with annotations
2021-02-25 11:59:41 +00:00
* `GskRenderer` is a class that renders a scene graph defined via a
* tree of [class@Gsk.RenderNode] instances.
docs: Add more GSK documentation
2016-07-03 23:23:19 +00:00
*
gskrenderer: Add property annotations Connect properties, getters, and setters with annotations
2021-02-25 11:59:41 +00:00
* Typically you will use a `GskRenderer` instance to repeatedly call
* [method@Gsk.Renderer.render] to update the contents of its associated
* [class@Gdk.Surface].
docs: Add more GSK documentation
2016-07-03 23:23:19 +00:00
*
gskrenderer: Add property annotations Connect properties, getters, and setters with annotations
2021-02-25 11:59:41 +00:00
* It is necessary to realize a `GskRenderer` instance using
* [method@Gsk.Renderer.realize] before calling [method@Gsk.Renderer.render],
* in order to create the appropriate windowing system resources needed
* to render the scene.
Initial implementation of GSK rendering pipeline GSK is conceptually split into two scene graphs: * a simple rendering tree of operations * a complex set of logical layers The latter is built on the former, and adds convenience and high level API for application developers. The lower layer, though, is what gets transformed into the rendering pipeline, as it's simple and thus can be transformed into appropriate rendering commands with minimal state changes. The lower layer is also suitable for reuse from more complex higher layers, like the CSS machinery in GTK, without necessarily port those layers to the GSK high level API. This lower layer is based on GskRenderNode instances, which represent the tree of rendering operations; and a GskRenderer instance, which takes the render nodes and submits them (after potentially reordering and transforming them to a more appropriate representation) to the underlying graphic system.
2016-03-17 13:48:19 +00:00
*/
#include "config.h"
#include "gskrendererprivate.h"
gsk: Export Cairo renderer
2019-05-01 21:58:57 +00:00
#include "gskcairorenderer.h"
Initial implementation of GSK rendering pipeline GSK is conceptually split into two scene graphs: * a simple rendering tree of operations * a complex set of logical layers The latter is built on the former, and adds convenience and high level API for application developers. The lower layer, though, is what gets transformed into the rendering pipeline, as it's simple and thus can be transformed into appropriate rendering commands with minimal state changes. The lower layer is also suitable for reuse from more complex higher layers, like the CSS machinery in GTK, without necessarily port those layers to the GSK high level API. This lower layer is based on GskRenderNode instances, which represent the tree of rendering operations; and a GskRenderer instance, which takes the render nodes and submits them (after potentially reordering and transforming them to a more appropriate representation) to the underlying graphic system.
2016-03-17 13:48:19 +00:00
#include "gskdebugprivate.h"
gsk: Add GskProfiler to GskRenderer The profiler instance is per-renderer, and is accesible to implementations.
2016-08-03 15:51:21 +00:00
#include "gskprofilerprivate.h"
Initial implementation of GSK rendering pipeline GSK is conceptually split into two scene graphs: * a simple rendering tree of operations * a complex set of logical layers The latter is built on the former, and adds convenience and high level API for application developers. The lower layer, though, is what gets transformed into the rendering pipeline, as it's simple and thus can be transformed into appropriate rendering commands with minimal state changes. The lower layer is also suitable for reuse from more complex higher layers, like the CSS machinery in GTK, without necessarily port those layers to the GSK high level API. This lower layer is based on GskRenderNode instances, which represent the tree of rendering operations; and a GskRenderer instance, which takes the render nodes and submits them (after potentially reordering and transforming them to a more appropriate representation) to the underlying graphic system.
2016-03-17 13:48:19 +00:00
#include "gskrendernodeprivate.h"
gsk: Prepare subsurface offload Use a GskOffloadInfo to update subsurfaces (and collect info about them). Pass that info to both the diff and the render vfuncs.
2023-10-31 23:19:32 +00:00
#include "gskoffloadprivate.h"
Initial implementation of GSK rendering pipeline GSK is conceptually split into two scene graphs: * a simple rendering tree of operations * a complex set of logical layers The latter is built on the former, and adds convenience and high level API for application developers. The lower layer, though, is what gets transformed into the rendering pipeline, as it's simple and thus can be transformed into appropriate rendering commands with minimal state changes. The lower layer is also suitable for reuse from more complex higher layers, like the CSS machinery in GTK, without necessarily port those layers to the GSK high level API. This lower layer is based on GskRenderNode instances, which represent the tree of rendering operations; and a GskRenderer instance, which takes the render nodes and submits them (after potentially reordering and transforming them to a more appropriate representation) to the underlying graphic system.
2016-03-17 13:48:19 +00:00
#include "gskenumtypes.h"
gsk: include Vulkan renderer in public header The Vulkan renderer can just be public API, because it doesn't expose any Vulkan-specific APIs. And it can just exist when compiled without Vulkan, because it can fail to realize. Also move get rid of the gsk/vulkan/gskvulkanrenderer.h header. It was experimental and isn't necessary now that the renderer is included via gsk.h.
2024-01-06 18:58:24 +00:00
#include "gl/gskglrenderer.h"
#include "gpu/gskvulkanrenderer.h"
gsk: Don't use gpu renderers with llvmpipe Unless the renderer has been explicitly selected via the GSK_RENDERER environment variable, don't use it with llvmpipe. It is important that we allow explicit setting to override this, so we can continue to use ngl in ci, where we don't have hw and want to test with llvmpipe. This should address many of the "performance is terrible in GNOME OS" complaints that are coming from people running in VMs, etc.
2024-02-12 19:16:09 +00:00
#include "gdk/gdkvulkancontextprivate.h"
#include "gdk/gdkdisplayprivate.h"
gsk: include Vulkan renderer in public header The Vulkan renderer can just be public API, because it doesn't expose any Vulkan-specific APIs. And it can just exist when compiled without Vulkan, because it can fail to realize. Also move get rid of the gsk/vulkan/gskvulkanrenderer.h header. It was experimental and isn't necessary now that the renderer is included via gsk.h.
2024-01-06 18:58:24 +00:00
Initial implementation of GSK rendering pipeline GSK is conceptually split into two scene graphs: * a simple rendering tree of operations * a complex set of logical layers The latter is built on the former, and adds convenience and high level API for application developers. The lower layer, though, is what gets transformed into the rendering pipeline, as it's simple and thus can be transformed into appropriate rendering commands with minimal state changes. The lower layer is also suitable for reuse from more complex higher layers, like the CSS machinery in GTK, without necessarily port those layers to the GSK high level API. This lower layer is based on GskRenderNode instances, which represent the tree of rendering operations; and a GskRenderer instance, which takes the render nodes and submits them (after potentially reordering and transforming them to a more appropriate representation) to the underlying graphic system.
2016-03-17 13:48:19 +00:00
#include <graphene-gobject.h>
#include <cairo-gobject.h>
#include <gdk/gdk.h>
Change the offload-disable flag Move this from GSK_DEBUG=offload-disable to GDK_DISABLE=offload.
2024-08-19 20:20:11 +00:00
#include "gdk/gdkdebugprivate.h"
Initial implementation of GSK rendering pipeline GSK is conceptually split into two scene graphs: * a simple rendering tree of operations * a complex set of logical layers The latter is built on the former, and adds convenience and high level API for application developers. The lower layer, though, is what gets transformed into the rendering pipeline, as it's simple and thus can be transformed into appropriate rendering commands with minimal state changes. The lower layer is also suitable for reuse from more complex higher layers, like the CSS machinery in GTK, without necessarily port those layers to the GSK high level API. This lower layer is based on GskRenderNode instances, which represent the tree of rendering operations; and a GskRenderer instance, which takes the render nodes and submits them (after potentially reordering and transforming them to a more appropriate representation) to the underlying graphic system.
2016-03-17 13:48:19 +00:00
#ifdef GDK_WINDOWING_X11
#include <gdk/x11/gdkx.h>
#endif
#ifdef GDK_WINDOWING_WAYLAND
#include <gdk/wayland/gdkwayland.h>
#endif
broadway: Add GskBroadwayRenderer This is a custom renderer for broadway windows, although at the moment it doesn't really do anything other than the old cairo fallbacks.
2017-11-17 11:04:02 +00:00
#ifdef GDK_WINDOWING_BROADWAY
gsk: Export gsk_broadway_renderer_new() ... when broadway is enabled.
2019-05-02 00:46:23 +00:00
#include "broadway/gskbroadwayrenderer.h"
broadway: Add GskBroadwayRenderer This is a custom renderer for broadway windows, although at the moment it doesn't really do anything other than the old cairo fallbacks.
2017-11-17 11:04:02 +00:00
#endif
macos: prototype new GDK backend for macOS This is fairly substantial rewrite of the GDK backend for quartz and renamed to macOS to allow for a greenfield implementation. Many things have come across from the quartz implementation fairly intact such as the eventloop integration design and discovery of event windows from the NSEvent. However much has been changed to fit in with the new GDK design and how removal of child GdkWindow have been completely eliminated. Furthermore, the new GdkPopup allows for regular NSWindow to be used to provide popovers unlike the previous implementation. The object design more closely follows the ideal for a GDK backend. Views have been broken out into subclasses so that we can support multiple GSK renderer paths such as GL and Cairo (and Metal in the future). However mixed mode GL and Cairo will not be supported. Currently only the Cairo renderer has been implemented. A new frame clock implementation using CVDisplayLink provides more accurate information about when to draw drawing the next frame. Some testing will need to be done here to understand the power implications of this. This implementation has also gained edge snapping for CSD windows. Some work was also done to ensure that CSD windows have opaque regions registered with the display server. ** This is still very much a work-in-progress ** Some outstanding work that needs to be done: - Finish a GL context for macOS and alternate NSView for GL rendering (possibly using speciailized CALayer for OpenGL). - Input rework to ensure that we don't loose remapping of keys that was dropped from GDK during GTK 4 development. - Make sure input methods continue to work. - Drag-n-Drop is still very much a work in progress - High resolution input scrolling needs various work in GDK to land first before we can plumb that to NSEvent. - gtk/ has a number of things based on GDK_WINDOWING_QUARTZ that need to be updated to use the macOS backend. But this is good enough to start playing with and breaking things which is what I'd like to see.
2020-04-23 23:36:46 +00:00
#ifdef GDK_WINDOWING_MACOS
#include <gdk/macos/gdkmacos.h>
#endif
gskrenderer.c: Default to the GL renderer on Windows too Since we have now made the Win32 GL contexts share the global context as the other backends have, we are more ready to use the GL renderer by default on Windows as well. Note that currently we can only enable this when not running on OpenGL/ES as the OpenGL/ES shaders are not ready at this point, and the OpenGL/ES support that we have from libANGLE does not support full desktop OpenGL operations.
2020-07-31 10:44:10 +00:00
#ifdef GDK_WINDOWING_WIN32
#include <gdk/win32/gdkwin32.h>
/* Remove these lines when OpenGL/ES 2.0 shader is ready */
#include "win32/gdkprivate-win32.h"
#include "win32/gdkdisplay-win32.h"
#endif
Initial implementation of GSK rendering pipeline GSK is conceptually split into two scene graphs: * a simple rendering tree of operations * a complex set of logical layers The latter is built on the former, and adds convenience and high level API for application developers. The lower layer, though, is what gets transformed into the rendering pipeline, as it's simple and thus can be transformed into appropriate rendering commands with minimal state changes. The lower layer is also suitable for reuse from more complex higher layers, like the CSS machinery in GTK, without necessarily port those layers to the GSK high level API. This lower layer is based on GskRenderNode instances, which represent the tree of rendering operations; and a GskRenderer instance, which takes the render nodes and submits them (after potentially reordering and transforming them to a more appropriate representation) to the underlying graphic system.
2016-03-17 13:48:19 +00:00
typedef struct
{
GObject parent_instance;
Continue renaming window to surface This renames a lot of arguments, local variables and functions.
2018-03-21 10:49:14 +00:00
GdkSurface *surface;
renderer: Track the previous node ... and diff the previous node with the current one to determine the clip region. This doubles the work necessary to track clip regions, but the following commits will clean that up.
2018-03-28 13:43:43 +00:00
GskRenderNode *prev_node;
Initial implementation of GSK rendering pipeline GSK is conceptually split into two scene graphs: * a simple rendering tree of operations * a complex set of logical layers The latter is built on the former, and adds convenience and high level API for application developers. The lower layer, though, is what gets transformed into the rendering pipeline, as it's simple and thus can be transformed into appropriate rendering commands with minimal state changes. The lower layer is also suitable for reuse from more complex higher layers, like the CSS machinery in GTK, without necessarily port those layers to the GSK high level API. This lower layer is based on GskRenderNode instances, which represent the tree of rendering operations; and a GskRenderer instance, which takes the render nodes and submits them (after potentially reordering and transforming them to a more appropriate representation) to the underlying graphic system.
2016-03-17 13:48:19 +00:00
gsk: Add GskProfiler to GskRenderer The profiler instance is per-renderer, and is accesible to implementations.
2016-08-03 15:51:21 +00:00
GskProfiler *profiler;
gsk: make logging per-renderer Add a setter for per-renderer debug flags, and use them where possible. Some places don't have easy access to a renderer, so this is not complete. Also, use g_message instead of g_print throughout.
2018-01-14 14:52:52 +00:00
GskDebugFlags debug_flags;
Fix various bitfield warnings clang rightly complains about using gboolean as type for bitfields, since it is signed. Avoid that.
2023-04-27 04:46:36 +00:00
unsigned int is_realized : 1;
Initial implementation of GSK rendering pipeline GSK is conceptually split into two scene graphs: * a simple rendering tree of operations * a complex set of logical layers The latter is built on the former, and adds convenience and high level API for application developers. The lower layer, though, is what gets transformed into the rendering pipeline, as it's simple and thus can be transformed into appropriate rendering commands with minimal state changes. The lower layer is also suitable for reuse from more complex higher layers, like the CSS machinery in GTK, without necessarily port those layers to the GSK high level API. This lower layer is based on GskRenderNode instances, which represent the tree of rendering operations; and a GskRenderer instance, which takes the render nodes and submits them (after potentially reordering and transforming them to a more appropriate representation) to the underlying graphic system.
2016-03-17 13:48:19 +00:00
} GskRendererPrivate;
G_DEFINE_ABSTRACT_TYPE_WITH_PRIVATE (GskRenderer, gsk_renderer, G_TYPE_OBJECT)
enum {
renderer: Make gsk_renderer_is_realized() public ... and add a property for it.
2019-03-09 12:59:03 +00:00
PROP_0,
PROP_REALIZED,
PROP_SURFACE,
Initial implementation of GSK rendering pipeline GSK is conceptually split into two scene graphs: * a simple rendering tree of operations * a complex set of logical layers The latter is built on the former, and adds convenience and high level API for application developers. The lower layer, though, is what gets transformed into the rendering pipeline, as it's simple and thus can be transformed into appropriate rendering commands with minimal state changes. The lower layer is also suitable for reuse from more complex higher layers, like the CSS machinery in GTK, without necessarily port those layers to the GSK high level API. This lower layer is based on GskRenderNode instances, which represent the tree of rendering operations; and a GskRenderer instance, which takes the render nodes and submits them (after potentially reordering and transforming them to a more appropriate representation) to the underlying graphic system.
2016-03-17 13:48:19 +00:00
N_PROPS
};
static GParamSpec *gsk_renderer_properties[N_PROPS];
#define GSK_RENDERER_WARN_NOT_IMPLEMENTED_METHOD(obj,method) \
g_critical ("Renderer of type '%s' does not implement GskRenderer::" # method, G_OBJECT_TYPE_NAME (obj))
static gboolean
gskrenderer: Add GError argument to gsk_renderer_realize() This way, we don't spam criticals when GL is not available. Instead, we print a useful debug message to stderr and continue with the Cairo renderer. Signed-off-by: Emmanuele Bassi <ebassi@gnome.org>
2016-11-29 03:51:07 +00:00
gsk_renderer_real_realize (GskRenderer *self,
renderer: Pass the display as part of the vfunc We allow realizing renderers without surfaces. But they still need a display, so pass it explicitly.
2024-01-07 09:00:04 +00:00
GdkDisplay *display,
gsk: Allow gsk_renderer_realize (renderer, NULL, NULL) That way, we can use renderers without surfaces.
2021-10-20 18:30:08 +00:00
GdkSurface *surface,
gskrenderer: Add GError argument to gsk_renderer_realize() This way, we don't spam criticals when GL is not available. Instead, we print a useful debug message to stderr and continue with the Cairo renderer. Signed-off-by: Emmanuele Bassi <ebassi@gnome.org>
2016-11-29 03:51:07 +00:00
GError **error)
Initial implementation of GSK rendering pipeline GSK is conceptually split into two scene graphs: * a simple rendering tree of operations * a complex set of logical layers The latter is built on the former, and adds convenience and high level API for application developers. The lower layer, though, is what gets transformed into the rendering pipeline, as it's simple and thus can be transformed into appropriate rendering commands with minimal state changes. The lower layer is also suitable for reuse from more complex higher layers, like the CSS machinery in GTK, without necessarily port those layers to the GSK high level API. This lower layer is based on GskRenderNode instances, which represent the tree of rendering operations; and a GskRenderer instance, which takes the render nodes and submits them (after potentially reordering and transforming them to a more appropriate representation) to the underlying graphic system.
2016-03-17 13:48:19 +00:00
{
GSK_RENDERER_WARN_NOT_IMPLEMENTED_METHOD (self, realize);
return FALSE;
}
static void
gsk_renderer_real_unrealize (GskRenderer *self)
{
GSK_RENDERER_WARN_NOT_IMPLEMENTED_METHOD (self, unrealize);
}
GskTexture => GdkTexture We want this thing to replace GdkPixbuf, so it has to live in GDK.
2017-11-02 20:39:00 +00:00
static GdkTexture *
gsk: Add gsk_renderer_render_texture() ... and implement it for the Cairo renderer. It's an API that instructs a renderer to render to a texture. So far this is mostly meant to be used for testing, but I could imagine it being useful for rendering DND icons.
2016-12-21 19:23:46 +00:00
gsk_renderer_real_render_texture (GskRenderer *self,
GskRenderNode *root,
const graphene_rect_t *viewport)
{
GSK_RENDERER_WARN_NOT_IMPLEMENTED_METHOD (self, render_texture);
return NULL;
}
Initial implementation of GSK rendering pipeline GSK is conceptually split into two scene graphs: * a simple rendering tree of operations * a complex set of logical layers The latter is built on the former, and adds convenience and high level API for application developers. The lower layer, though, is what gets transformed into the rendering pipeline, as it's simple and thus can be transformed into appropriate rendering commands with minimal state changes. The lower layer is also suitable for reuse from more complex higher layers, like the CSS machinery in GTK, without necessarily port those layers to the GSK high level API. This lower layer is based on GskRenderNode instances, which represent the tree of rendering operations; and a GskRenderer instance, which takes the render nodes and submits them (after potentially reordering and transforming them to a more appropriate representation) to the underlying graphic system.
2016-03-17 13:48:19 +00:00
static void
gsk: move begin/end_frame vfuncs into the renderers
2018-03-28 13:01:34 +00:00
gsk_renderer_real_render (GskRenderer *self,
GskRenderNode *root,
renderer: Remove offload argument from render() It turns out it's not needed, because all relevant information for subsurfaces is already available by querying the subsurface itself.
2023-11-14 20:45:47 +00:00
const cairo_region_t *region)
Initial implementation of GSK rendering pipeline GSK is conceptually split into two scene graphs: * a simple rendering tree of operations * a complex set of logical layers The latter is built on the former, and adds convenience and high level API for application developers. The lower layer, though, is what gets transformed into the rendering pipeline, as it's simple and thus can be transformed into appropriate rendering commands with minimal state changes. The lower layer is also suitable for reuse from more complex higher layers, like the CSS machinery in GTK, without necessarily port those layers to the GSK high level API. This lower layer is based on GskRenderNode instances, which represent the tree of rendering operations; and a GskRenderer instance, which takes the render nodes and submits them (after potentially reordering and transforming them to a more appropriate representation) to the underlying graphic system.
2016-03-17 13:48:19 +00:00
{
GSK_RENDERER_WARN_NOT_IMPLEMENTED_METHOD (self, render);
}
static void
gsk_renderer_dispose (GObject *gobject)
{
GskRenderer *self = GSK_RENDERER (gobject);
GskRendererPrivate *priv = gsk_renderer_get_instance_private (self);
renderer: Assert having been unrealized in dispose We cannot unrealize a renderer in the dispose function, because that would cause this chain to happen: gsk_gl_renderer_dispose gsk_renderer_dispose gsk_renderer_unrealize gsk_gl_renderer_unrealize So we would call into thje GL renderers unrealize when it has already (partially) disposed itself and ause accesses to dead variables.
2017-11-04 14:09:43 +00:00
/* We can't just unrealize here because superclasses have already run dispose.
* So we insist that unrealize must be called before unreffing. */
g_assert (!priv->is_realized);
Initial implementation of GSK rendering pipeline GSK is conceptually split into two scene graphs: * a simple rendering tree of operations * a complex set of logical layers The latter is built on the former, and adds convenience and high level API for application developers. The lower layer, though, is what gets transformed into the rendering pipeline, as it's simple and thus can be transformed into appropriate rendering commands with minimal state changes. The lower layer is also suitable for reuse from more complex higher layers, like the CSS machinery in GTK, without necessarily port those layers to the GSK high level API. This lower layer is based on GskRenderNode instances, which represent the tree of rendering operations; and a GskRenderer instance, which takes the render nodes and submits them (after potentially reordering and transforming them to a more appropriate representation) to the underlying graphic system.
2016-03-17 13:48:19 +00:00
gsk: Clear the profiler instance When disposing the GskRenderer.
2016-10-18 15:49:21 +00:00
g_clear_object (&priv->profiler);
Initial implementation of GSK rendering pipeline GSK is conceptually split into two scene graphs: * a simple rendering tree of operations * a complex set of logical layers The latter is built on the former, and adds convenience and high level API for application developers. The lower layer, though, is what gets transformed into the rendering pipeline, as it's simple and thus can be transformed into appropriate rendering commands with minimal state changes. The lower layer is also suitable for reuse from more complex higher layers, like the CSS machinery in GTK, without necessarily port those layers to the GSK high level API. This lower layer is based on GskRenderNode instances, which represent the tree of rendering operations; and a GskRenderer instance, which takes the render nodes and submits them (after potentially reordering and transforming them to a more appropriate representation) to the underlying graphic system.
2016-03-17 13:48:19 +00:00
G_OBJECT_CLASS (gsk_renderer_parent_class)->dispose (gobject);
}
static void
gsk_renderer_get_property (GObject *gobject,
guint prop_id,
GValue *value,
GParamSpec *pspec)
{
GskRenderer *self = GSK_RENDERER (gobject);
GskRendererPrivate *priv = gsk_renderer_get_instance_private (self);
switch (prop_id)
{
renderer: Make gsk_renderer_is_realized() public ... and add a property for it.
2019-03-09 12:59:03 +00:00
case PROP_REALIZED:
g_value_set_boolean (value, priv->is_realized);
break;
Continue renaming window to surface This renames a lot of arguments, local variables and functions.
2018-03-21 10:49:14 +00:00
case PROP_SURFACE:
g_value_set_object (value, priv->surface);
Initial implementation of GSK rendering pipeline GSK is conceptually split into two scene graphs: * a simple rendering tree of operations * a complex set of logical layers The latter is built on the former, and adds convenience and high level API for application developers. The lower layer, though, is what gets transformed into the rendering pipeline, as it's simple and thus can be transformed into appropriate rendering commands with minimal state changes. The lower layer is also suitable for reuse from more complex higher layers, like the CSS machinery in GTK, without necessarily port those layers to the GSK high level API. This lower layer is based on GskRenderNode instances, which represent the tree of rendering operations; and a GskRenderer instance, which takes the render nodes and submits them (after potentially reordering and transforming them to a more appropriate representation) to the underlying graphic system.
2016-03-17 13:48:19 +00:00
break;
build: Enable -Wswitch-enum and -Wswitch-default This patch makes that work using 1 of 2 options: 1. Add all missing enums to the switch statement or 2. Cast the switch argument to a uint to avoid having to do that (mostly for GdkEventType). I even found a bug while doing that: clearing a GtkImage with a surface did not notify thae surface property. The reason for enabling this flag even though it is tedious at times is that it is very useful when adding values to an enum, because it makes GTK immediately warn about all the switch statements where this enum is relevant. And I expect changes to enums to be frequent during the GTK4 development cycle.
2017-10-06 19:19:42 +00:00
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (gobject, prop_id, pspec);
break;
Initial implementation of GSK rendering pipeline GSK is conceptually split into two scene graphs: * a simple rendering tree of operations * a complex set of logical layers The latter is built on the former, and adds convenience and high level API for application developers. The lower layer, though, is what gets transformed into the rendering pipeline, as it's simple and thus can be transformed into appropriate rendering commands with minimal state changes. The lower layer is also suitable for reuse from more complex higher layers, like the CSS machinery in GTK, without necessarily port those layers to the GSK high level API. This lower layer is based on GskRenderNode instances, which represent the tree of rendering operations; and a GskRenderer instance, which takes the render nodes and submits them (after potentially reordering and transforming them to a more appropriate representation) to the underlying graphic system.
2016-03-17 13:48:19 +00:00
}
}
static void
gsk_renderer_class_init (GskRendererClass *klass)
{
GObjectClass *gobject_class = G_OBJECT_CLASS (klass);
klass->realize = gsk_renderer_real_realize;
klass->unrealize = gsk_renderer_real_unrealize;
klass->render = gsk_renderer_real_render;
gsk: Add gsk_renderer_render_texture() ... and implement it for the Cairo renderer. It's an API that instructs a renderer to render to a texture. So far this is mostly meant to be used for testing, but I could imagine it being useful for rendering DND icons.
2016-12-21 19:23:46 +00:00
klass->render_texture = gsk_renderer_real_render_texture;
Initial implementation of GSK rendering pipeline GSK is conceptually split into two scene graphs: * a simple rendering tree of operations * a complex set of logical layers The latter is built on the former, and adds convenience and high level API for application developers. The lower layer, though, is what gets transformed into the rendering pipeline, as it's simple and thus can be transformed into appropriate rendering commands with minimal state changes. The lower layer is also suitable for reuse from more complex higher layers, like the CSS machinery in GTK, without necessarily port those layers to the GSK high level API. This lower layer is based on GskRenderNode instances, which represent the tree of rendering operations; and a GskRenderer instance, which takes the render nodes and submits them (after potentially reordering and transforming them to a more appropriate representation) to the underlying graphic system.
2016-03-17 13:48:19 +00:00
gobject_class->get_property = gsk_renderer_get_property;
gobject_class->dispose = gsk_renderer_dispose;
gskrenderer: Add property annotations Connect properties, getters, and setters with annotations
2021-02-25 11:59:41 +00:00
/**
docs: Use correct property gir annotations The annotations should only be set when the name of the setter or getter for a property "GtkClassName:prop-name" is not gtk_class_name_g(s)et_property_name.
2024-06-03 11:04:05 +00:00
* GskRenderer:realized: (getter is_realized)
gskrenderer: Add property annotations Connect properties, getters, and setters with annotations
2021-02-25 11:59:41 +00:00
*
gsk: Allow gsk_renderer_realize (renderer, NULL, NULL) That way, we can use renderers without surfaces.
2021-10-20 18:30:08 +00:00
* Whether the renderer has been associated with a surface or draw context.
gskrenderer: Add property annotations Connect properties, getters, and setters with annotations
2021-02-25 11:59:41 +00:00
*/
renderer: Make gsk_renderer_is_realized() public ... and add a property for it.
2019-03-09 12:59:03 +00:00
gsk_renderer_properties[PROP_REALIZED] =
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_boolean ("realized", NULL, NULL,
renderer: Make gsk_renderer_is_realized() public ... and add a property for it.
2019-03-09 12:59:03 +00:00
FALSE,
G_PARAM_READABLE | G_PARAM_EXPLICIT_NOTIFY | G_PARAM_STATIC_STRINGS);
gskrenderer: Add property annotations Connect properties, getters, and setters with annotations
2021-02-25 11:59:41 +00:00
/**
docs: Remove all org.gtk.Property annotations Removed via regex and grep. The following were intentionally not removed: - GtkImage:file: (attributes org.gtk.Property.set=gtk_image_set_from_file) - GtkImage:resource: (attributes org.gtk.Property.set=gtk_image_set_from_resource) As they have no getter and (setter PROP) without a (getter PROP) crash gobject-introspection. This is fixed by https://gitlab.gnome.org/GNOME/gobject-introspection/-/commit/ad3118eb519d40131ae90f4cf9b55c991c30821b.
2024-06-03 11:35:00 +00:00
* GskRenderer:surface:
gskrenderer: Add property annotations Connect properties, getters, and setters with annotations
2021-02-25 11:59:41 +00:00
*
* The surface associated with renderer.
*/
Continue renaming window to surface This renames a lot of arguments, local variables and functions.
2018-03-21 10:49:14 +00:00
gsk_renderer_properties[PROP_SURFACE] =
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 ("surface", NULL, NULL,
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
GDK_TYPE_SURFACE,
renderer: Make gsk_renderer_is_realized() public ... and add a property for it.
2019-03-09 12:59:03 +00:00
G_PARAM_READABLE | G_PARAM_EXPLICIT_NOTIFY | G_PARAM_STATIC_STRINGS);
gsk: Rework GskRenderer and GskRenderNode semantics This commit changes the way GskRenderer and GskRenderNode interact and are meant to be used. GskRenderNode should represent a transient tree of rendering nodes, which are submitted to the GskRenderer at render time; this allows the renderer to take ownership of the render tree. Once the toolkit and application code have finished assembling it, the render tree ownership is transferred to the renderer.
2016-06-22 16:30:36 +00:00
Initial implementation of GSK rendering pipeline GSK is conceptually split into two scene graphs: * a simple rendering tree of operations * a complex set of logical layers The latter is built on the former, and adds convenience and high level API for application developers. The lower layer, though, is what gets transformed into the rendering pipeline, as it's simple and thus can be transformed into appropriate rendering commands with minimal state changes. The lower layer is also suitable for reuse from more complex higher layers, like the CSS machinery in GTK, without necessarily port those layers to the GSK high level API. This lower layer is based on GskRenderNode instances, which represent the tree of rendering operations; and a GskRenderer instance, which takes the render nodes and submits them (after potentially reordering and transforming them to a more appropriate representation) to the underlying graphic system.
2016-03-17 13:48:19 +00:00
g_object_class_install_properties (gobject_class, N_PROPS, gsk_renderer_properties);
}
static void
gsk_renderer_init (GskRenderer *self)
{
GskRendererPrivate *priv = gsk_renderer_get_instance_private (self);
gsk: Add GskProfiler to GskRenderer The profiler instance is per-renderer, and is accesible to implementations.
2016-08-03 15:51:21 +00:00
priv->profiler = gsk_profiler_new ();
gsk: make logging per-renderer Add a setter for per-renderer debug flags, and use them where possible. Some places don't have easy access to a renderer, so this is not complete. Also, use g_message instead of g_print throughout.
2018-01-14 14:52:52 +00:00
priv->debug_flags = gsk_get_debug_flags ();
Initial implementation of GSK rendering pipeline GSK is conceptually split into two scene graphs: * a simple rendering tree of operations * a complex set of logical layers The latter is built on the former, and adds convenience and high level API for application developers. The lower layer, though, is what gets transformed into the rendering pipeline, as it's simple and thus can be transformed into appropriate rendering commands with minimal state changes. The lower layer is also suitable for reuse from more complex higher layers, like the CSS machinery in GTK, without necessarily port those layers to the GSK high level API. This lower layer is based on GskRenderNode instances, which represent the tree of rendering operations; and a GskRenderer instance, which takes the render nodes and submits them (after potentially reordering and transforming them to a more appropriate representation) to the underlying graphic system.
2016-03-17 13:48:19 +00:00
}
/**
docs: Remove all org.gtk.Method annotations Removed via regex and grep.
2024-06-03 11:36:59 +00:00
* gsk_renderer_get_surface:
gskrenderer: Add property annotations Connect properties, getters, and setters with annotations
2021-02-25 11:59:41 +00:00
* @renderer: a `GskRenderer`
*
* Retrieves the `GdkSurface` set using gsk_enderer_realize().
Initial implementation of GSK rendering pipeline GSK is conceptually split into two scene graphs: * a simple rendering tree of operations * a complex set of logical layers The latter is built on the former, and adds convenience and high level API for application developers. The lower layer, though, is what gets transformed into the rendering pipeline, as it's simple and thus can be transformed into appropriate rendering commands with minimal state changes. The lower layer is also suitable for reuse from more complex higher layers, like the CSS machinery in GTK, without necessarily port those layers to the GSK high level API. This lower layer is based on GskRenderNode instances, which represent the tree of rendering operations; and a GskRenderer instance, which takes the render nodes and submits them (after potentially reordering and transforming them to a more appropriate representation) to the underlying graphic system.
2016-03-17 13:48:19 +00:00
*
gskrenderer: Add property annotations Connect properties, getters, and setters with annotations
2021-02-25 11:59:41 +00:00
* If the renderer has not been realized yet, %NULL will be returned.
Initial implementation of GSK rendering pipeline GSK is conceptually split into two scene graphs: * a simple rendering tree of operations * a complex set of logical layers The latter is built on the former, and adds convenience and high level API for application developers. The lower layer, though, is what gets transformed into the rendering pipeline, as it's simple and thus can be transformed into appropriate rendering commands with minimal state changes. The lower layer is also suitable for reuse from more complex higher layers, like the CSS machinery in GTK, without necessarily port those layers to the GSK high level API. This lower layer is based on GskRenderNode instances, which represent the tree of rendering operations; and a GskRenderer instance, which takes the render nodes and submits them (after potentially reordering and transforming them to a more appropriate representation) to the underlying graphic system.
2016-03-17 13:48:19 +00:00
*
gskrenderer: Add property annotations Connect properties, getters, and setters with annotations
2021-02-25 11:59:41 +00:00
* Returns: (transfer none) (nullable): a `GdkSurface`
Initial implementation of GSK rendering pipeline GSK is conceptually split into two scene graphs: * a simple rendering tree of operations * a complex set of logical layers The latter is built on the former, and adds convenience and high level API for application developers. The lower layer, though, is what gets transformed into the rendering pipeline, as it's simple and thus can be transformed into appropriate rendering commands with minimal state changes. The lower layer is also suitable for reuse from more complex higher layers, like the CSS machinery in GTK, without necessarily port those layers to the GSK high level API. This lower layer is based on GskRenderNode instances, which represent the tree of rendering operations; and a GskRenderer instance, which takes the render nodes and submits them (after potentially reordering and transforming them to a more appropriate representation) to the underlying graphic system.
2016-03-17 13:48:19 +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
gsk_renderer_get_surface (GskRenderer *renderer)
Initial implementation of GSK rendering pipeline GSK is conceptually split into two scene graphs: * a simple rendering tree of operations * a complex set of logical layers The latter is built on the former, and adds convenience and high level API for application developers. The lower layer, though, is what gets transformed into the rendering pipeline, as it's simple and thus can be transformed into appropriate rendering commands with minimal state changes. The lower layer is also suitable for reuse from more complex higher layers, like the CSS machinery in GTK, without necessarily port those layers to the GSK high level API. This lower layer is based on GskRenderNode instances, which represent the tree of rendering operations; and a GskRenderer instance, which takes the render nodes and submits them (after potentially reordering and transforming them to a more appropriate representation) to the underlying graphic system.
2016-03-17 13:48:19 +00:00
{
GskRendererPrivate *priv = gsk_renderer_get_instance_private (renderer);
g_return_val_if_fail (GSK_IS_RENDERER (renderer), NULL);
Continue renaming window to surface This renames a lot of arguments, local variables and functions.
2018-03-21 10:49:14 +00:00
return priv->surface;
Initial implementation of GSK rendering pipeline GSK is conceptually split into two scene graphs: * a simple rendering tree of operations * a complex set of logical layers The latter is built on the former, and adds convenience and high level API for application developers. The lower layer, though, is what gets transformed into the rendering pipeline, as it's simple and thus can be transformed into appropriate rendering commands with minimal state changes. The lower layer is also suitable for reuse from more complex higher layers, like the CSS machinery in GTK, without necessarily port those layers to the GSK high level API. This lower layer is based on GskRenderNode instances, which represent the tree of rendering operations; and a GskRenderer instance, which takes the render nodes and submits them (after potentially reordering and transforming them to a more appropriate representation) to the underlying graphic system.
2016-03-17 13:48:19 +00:00
}
/**
docs: Use correct property gir annotations The annotations should only be set when the name of the setter or getter for a property "GtkClassName:prop-name" is not gtk_class_name_g(s)et_property_name.
2024-06-03 11:04:05 +00:00
* gsk_renderer_is_realized: (get-property realized)
gskrenderer: Add property annotations Connect properties, getters, and setters with annotations
2021-02-25 11:59:41 +00:00
* @renderer: a `GskRenderer`
Initial implementation of GSK rendering pipeline GSK is conceptually split into two scene graphs: * a simple rendering tree of operations * a complex set of logical layers The latter is built on the former, and adds convenience and high level API for application developers. The lower layer, though, is what gets transformed into the rendering pipeline, as it's simple and thus can be transformed into appropriate rendering commands with minimal state changes. The lower layer is also suitable for reuse from more complex higher layers, like the CSS machinery in GTK, without necessarily port those layers to the GSK high level API. This lower layer is based on GskRenderNode instances, which represent the tree of rendering operations; and a GskRenderer instance, which takes the render nodes and submits them (after potentially reordering and transforming them to a more appropriate representation) to the underlying graphic system.
2016-03-17 13:48:19 +00:00
*
gsk: Rework GskRenderer and GskRenderNode semantics This commit changes the way GskRenderer and GskRenderNode interact and are meant to be used. GskRenderNode should represent a transient tree of rendering nodes, which are submitted to the GskRenderer at render time; this allows the renderer to take ownership of the render tree. Once the toolkit and application code have finished assembling it, the render tree ownership is transferred to the renderer.
2016-06-22 16:30:36 +00:00
* Checks whether the @renderer is realized or not.
Initial implementation of GSK rendering pipeline GSK is conceptually split into two scene graphs: * a simple rendering tree of operations * a complex set of logical layers The latter is built on the former, and adds convenience and high level API for application developers. The lower layer, though, is what gets transformed into the rendering pipeline, as it's simple and thus can be transformed into appropriate rendering commands with minimal state changes. The lower layer is also suitable for reuse from more complex higher layers, like the CSS machinery in GTK, without necessarily port those layers to the GSK high level API. This lower layer is based on GskRenderNode instances, which represent the tree of rendering operations; and a GskRenderer instance, which takes the render nodes and submits them (after potentially reordering and transforming them to a more appropriate representation) to the underlying graphic system.
2016-03-17 13:48:19 +00:00
*
gskrenderer: Add property annotations Connect properties, getters, and setters with annotations
2021-02-25 11:59:41 +00:00
* Returns: %TRUE if the `GskRenderer` was realized, and %FALSE otherwise
Initial implementation of GSK rendering pipeline GSK is conceptually split into two scene graphs: * a simple rendering tree of operations * a complex set of logical layers The latter is built on the former, and adds convenience and high level API for application developers. The lower layer, though, is what gets transformed into the rendering pipeline, as it's simple and thus can be transformed into appropriate rendering commands with minimal state changes. The lower layer is also suitable for reuse from more complex higher layers, like the CSS machinery in GTK, without necessarily port those layers to the GSK high level API. This lower layer is based on GskRenderNode instances, which represent the tree of rendering operations; and a GskRenderer instance, which takes the render nodes and submits them (after potentially reordering and transforming them to a more appropriate representation) to the underlying graphic system.
2016-03-17 13:48:19 +00:00
*/
gsk: Rework GskRenderer and GskRenderNode semantics This commit changes the way GskRenderer and GskRenderNode interact and are meant to be used. GskRenderNode should represent a transient tree of rendering nodes, which are submitted to the GskRenderer at render time; this allows the renderer to take ownership of the render tree. Once the toolkit and application code have finished assembling it, the render tree ownership is transferred to the renderer.
2016-06-22 16:30:36 +00:00
gboolean
gsk_renderer_is_realized (GskRenderer *renderer)
Initial implementation of GSK rendering pipeline GSK is conceptually split into two scene graphs: * a simple rendering tree of operations * a complex set of logical layers The latter is built on the former, and adds convenience and high level API for application developers. The lower layer, though, is what gets transformed into the rendering pipeline, as it's simple and thus can be transformed into appropriate rendering commands with minimal state changes. The lower layer is also suitable for reuse from more complex higher layers, like the CSS machinery in GTK, without necessarily port those layers to the GSK high level API. This lower layer is based on GskRenderNode instances, which represent the tree of rendering operations; and a GskRenderer instance, which takes the render nodes and submits them (after potentially reordering and transforming them to a more appropriate representation) to the underlying graphic system.
2016-03-17 13:48:19 +00:00
{
GskRendererPrivate *priv = gsk_renderer_get_instance_private (renderer);
gsk: Rework GskRenderer and GskRenderNode semantics This commit changes the way GskRenderer and GskRenderNode interact and are meant to be used. GskRenderNode should represent a transient tree of rendering nodes, which are submitted to the GskRenderer at render time; this allows the renderer to take ownership of the render tree. Once the toolkit and application code have finished assembling it, the render tree ownership is transferred to the renderer.
2016-06-22 16:30:36 +00:00
g_return_val_if_fail (GSK_IS_RENDERER (renderer), FALSE);
Initial implementation of GSK rendering pipeline GSK is conceptually split into two scene graphs: * a simple rendering tree of operations * a complex set of logical layers The latter is built on the former, and adds convenience and high level API for application developers. The lower layer, though, is what gets transformed into the rendering pipeline, as it's simple and thus can be transformed into appropriate rendering commands with minimal state changes. The lower layer is also suitable for reuse from more complex higher layers, like the CSS machinery in GTK, without necessarily port those layers to the GSK high level API. This lower layer is based on GskRenderNode instances, which represent the tree of rendering operations; and a GskRenderer instance, which takes the render nodes and submits them (after potentially reordering and transforming them to a more appropriate representation) to the underlying graphic system.
2016-03-17 13:48:19 +00:00
gsk: Rework GskRenderer and GskRenderNode semantics This commit changes the way GskRenderer and GskRenderNode interact and are meant to be used. GskRenderNode should represent a transient tree of rendering nodes, which are submitted to the GskRenderer at render time; this allows the renderer to take ownership of the render tree. Once the toolkit and application code have finished assembling it, the render tree ownership is transferred to the renderer.
2016-06-22 16:30:36 +00:00
return priv->is_realized;
Initial implementation of GSK rendering pipeline GSK is conceptually split into two scene graphs: * a simple rendering tree of operations * a complex set of logical layers The latter is built on the former, and adds convenience and high level API for application developers. The lower layer, though, is what gets transformed into the rendering pipeline, as it's simple and thus can be transformed into appropriate rendering commands with minimal state changes. The lower layer is also suitable for reuse from more complex higher layers, like the CSS machinery in GTK, without necessarily port those layers to the GSK high level API. This lower layer is based on GskRenderNode instances, which represent the tree of rendering operations; and a GskRenderer instance, which takes the render nodes and submits them (after potentially reordering and transforming them to a more appropriate representation) to the underlying graphic system.
2016-03-17 13:48:19 +00:00
}
renderer: Pass the display as part of the vfunc We allow realizing renderers without surfaces. But they still need a display, so pass it explicitly.
2024-01-07 09:00:04 +00:00
static gboolean
gsk_renderer_do_realize (GskRenderer *renderer,
GdkDisplay *display,
GdkSurface *surface,
GError **error)
{
GskRendererPrivate *priv = gsk_renderer_get_instance_private (renderer);
if (surface)
priv->surface = g_object_ref (surface);
if (!GSK_RENDERER_GET_CLASS (renderer)->realize (renderer, display, surface, error))
{
g_clear_object (&priv->surface);
return FALSE;
}
priv->is_realized = TRUE;
g_object_notify (G_OBJECT (renderer), "realized");
if (surface)
g_object_notify (G_OBJECT (renderer), "surface");
return TRUE;
}
Initial implementation of GSK rendering pipeline GSK is conceptually split into two scene graphs: * a simple rendering tree of operations * a complex set of logical layers The latter is built on the former, and adds convenience and high level API for application developers. The lower layer, though, is what gets transformed into the rendering pipeline, as it's simple and thus can be transformed into appropriate rendering commands with minimal state changes. The lower layer is also suitable for reuse from more complex higher layers, like the CSS machinery in GTK, without necessarily port those layers to the GSK high level API. This lower layer is based on GskRenderNode instances, which represent the tree of rendering operations; and a GskRenderer instance, which takes the render nodes and submits them (after potentially reordering and transforming them to a more appropriate representation) to the underlying graphic system.
2016-03-17 13:48:19 +00:00
/**
* gsk_renderer_realize:
gskrenderer: Add property annotations Connect properties, getters, and setters with annotations
2021-02-25 11:59:41 +00:00
* @renderer: a `GskRenderer`
gsk: Allow gsk_renderer_realize (renderer, NULL, NULL) That way, we can use renderers without surfaces.
2021-10-20 18:30:08 +00:00
* @surface: (nullable): the `GdkSurface` renderer will be used on
gskrenderer: Add GError argument to gsk_renderer_realize() This way, we don't spam criticals when GL is not available. Instead, we print a useful debug message to stderr and continue with the Cairo renderer. Signed-off-by: Emmanuele Bassi <ebassi@gnome.org>
2016-11-29 03:51:07 +00:00
* @error: return location for an error
Initial implementation of GSK rendering pipeline GSK is conceptually split into two scene graphs: * a simple rendering tree of operations * a complex set of logical layers The latter is built on the former, and adds convenience and high level API for application developers. The lower layer, though, is what gets transformed into the rendering pipeline, as it's simple and thus can be transformed into appropriate rendering commands with minimal state changes. The lower layer is also suitable for reuse from more complex higher layers, like the CSS machinery in GTK, without necessarily port those layers to the GSK high level API. This lower layer is based on GskRenderNode instances, which represent the tree of rendering operations; and a GskRenderer instance, which takes the render nodes and submits them (after potentially reordering and transforming them to a more appropriate representation) to the underlying graphic system.
2016-03-17 13:48:19 +00:00
*
* Creates the resources needed by the @renderer to render the scene
* graph.
gsk: Allow gsk_renderer_realize (renderer, NULL, NULL) That way, we can use renderers without surfaces.
2021-10-20 18:30:08 +00:00
*
* Since GTK 4.6, the surface may be `NULL`, which allows using
* renderers without having to create a surface.
API: Add gsk_renderer_realize_for_display() This makes realizing a renderer without a surface explicit. And more importantly, it allows passing a different display than the default one.
2024-01-07 09:00:38 +00:00
* Since GTK 4.14, it is recommended to use [method@Gsk.Renderer.realize_for_display]
* instead.
gsk: Document gsk_renderer_realize() Document the return value and more importantly, specify that a call to `gsk_renderer_realize()` needs to be matched with a call `gsk_renderer_unrealize()`. Prevents issues like https://gitlab.gnome.org/GNOME/gtk/-/issues/4625
2022-01-11 09:04:16 +00:00
*
* Note that it is mandatory to call [method@Gsk.Renderer.unrealize] before
* destroying the renderer.
*
* Returns: Whether the renderer was successfully realized
Initial implementation of GSK rendering pipeline GSK is conceptually split into two scene graphs: * a simple rendering tree of operations * a complex set of logical layers The latter is built on the former, and adds convenience and high level API for application developers. The lower layer, though, is what gets transformed into the rendering pipeline, as it's simple and thus can be transformed into appropriate rendering commands with minimal state changes. The lower layer is also suitable for reuse from more complex higher layers, like the CSS machinery in GTK, without necessarily port those layers to the GSK high level API. This lower layer is based on GskRenderNode instances, which represent the tree of rendering operations; and a GskRenderer instance, which takes the render nodes and submits them (after potentially reordering and transforming them to a more appropriate representation) to the underlying graphic system.
2016-03-17 13:48:19 +00:00
*/
gboolean
gskrenderer: Add GError argument to gsk_renderer_realize() This way, we don't spam criticals when GL is not available. Instead, we print a useful debug message to stderr and continue with the Cairo renderer. Signed-off-by: Emmanuele Bassi <ebassi@gnome.org>
2016-11-29 03:51:07 +00:00
gsk_renderer_realize (GskRenderer *renderer,
gsk: Document gsk_renderer_realize() Document the return value and more importantly, specify that a call to `gsk_renderer_realize()` needs to be matched with a call `gsk_renderer_unrealize()`. Prevents issues like https://gitlab.gnome.org/GNOME/gtk/-/issues/4625
2022-01-11 09:04:16 +00:00
GdkSurface *surface,
gskrenderer: Add GError argument to gsk_renderer_realize() This way, we don't spam criticals when GL is not available. Instead, we print a useful debug message to stderr and continue with the Cairo renderer. Signed-off-by: Emmanuele Bassi <ebassi@gnome.org>
2016-11-29 03:51:07 +00:00
GError **error)
Initial implementation of GSK rendering pipeline GSK is conceptually split into two scene graphs: * a simple rendering tree of operations * a complex set of logical layers The latter is built on the former, and adds convenience and high level API for application developers. The lower layer, though, is what gets transformed into the rendering pipeline, as it's simple and thus can be transformed into appropriate rendering commands with minimal state changes. The lower layer is also suitable for reuse from more complex higher layers, like the CSS machinery in GTK, without necessarily port those layers to the GSK high level API. This lower layer is based on GskRenderNode instances, which represent the tree of rendering operations; and a GskRenderer instance, which takes the render nodes and submits them (after potentially reordering and transforming them to a more appropriate representation) to the underlying graphic system.
2016-03-17 13:48:19 +00:00
{
g_return_val_if_fail (GSK_IS_RENDERER (renderer), FALSE);
gsk: Change gsk_renderer_realize() Instead of having a gsk_renderer_set_window() call, pass the window to realize(). This way, the realization can fail with the wrong window. Signed-off-by: Emmanuele Bassi <ebassi@gnome.org>
2016-11-29 02:36:33 +00:00
g_return_val_if_fail (!gsk_renderer_is_realized (renderer), FALSE);
gsk: Allow gsk_renderer_realize (renderer, NULL, NULL) That way, we can use renderers without surfaces.
2021-10-20 18:30:08 +00:00
g_return_val_if_fail (surface == NULL || GDK_IS_SURFACE (surface), FALSE);
gskrenderer: Add GError argument to gsk_renderer_realize() This way, we don't spam criticals when GL is not available. Instead, we print a useful debug message to stderr and continue with the Cairo renderer. Signed-off-by: Emmanuele Bassi <ebassi@gnome.org>
2016-11-29 03:51:07 +00:00
g_return_val_if_fail (error == NULL || *error == NULL, FALSE);
Initial implementation of GSK rendering pipeline GSK is conceptually split into two scene graphs: * a simple rendering tree of operations * a complex set of logical layers The latter is built on the former, and adds convenience and high level API for application developers. The lower layer, though, is what gets transformed into the rendering pipeline, as it's simple and thus can be transformed into appropriate rendering commands with minimal state changes. The lower layer is also suitable for reuse from more complex higher layers, like the CSS machinery in GTK, without necessarily port those layers to the GSK high level API. This lower layer is based on GskRenderNode instances, which represent the tree of rendering operations; and a GskRenderer instance, which takes the render nodes and submits them (after potentially reordering and transforming them to a more appropriate representation) to the underlying graphic system.
2016-03-17 13:48:19 +00:00
renderer: Pass the display as part of the vfunc We allow realizing renderers without surfaces. But they still need a display, so pass it explicitly.
2024-01-07 09:00:04 +00:00
if (surface == NULL)
gsk: Change gsk_renderer_realize() Instead of having a gsk_renderer_set_window() call, pass the window to realize(). This way, the realization can fail with the wrong window. Signed-off-by: Emmanuele Bassi <ebassi@gnome.org>
2016-11-29 02:36:33 +00:00
{
renderer: Pass the display as part of the vfunc We allow realizing renderers without surfaces. But they still need a display, so pass it explicitly.
2024-01-07 09:00:04 +00:00
return gsk_renderer_do_realize (renderer,
gdk_display_get_default (),
NULL,
error);
gsk: Change gsk_renderer_realize() Instead of having a gsk_renderer_set_window() call, pass the window to realize(). This way, the realization can fail with the wrong window. Signed-off-by: Emmanuele Bassi <ebassi@gnome.org>
2016-11-29 02:36:33 +00:00
}
renderer: Pass the display as part of the vfunc We allow realizing renderers without surfaces. But they still need a display, so pass it explicitly.
2024-01-07 09:00:04 +00:00
else
{
return gsk_renderer_do_realize (renderer,
gdk_surface_get_display (surface),
surface,
error);
}
}
Initial implementation of GSK rendering pipeline GSK is conceptually split into two scene graphs: * a simple rendering tree of operations * a complex set of logical layers The latter is built on the former, and adds convenience and high level API for application developers. The lower layer, though, is what gets transformed into the rendering pipeline, as it's simple and thus can be transformed into appropriate rendering commands with minimal state changes. The lower layer is also suitable for reuse from more complex higher layers, like the CSS machinery in GTK, without necessarily port those layers to the GSK high level API. This lower layer is based on GskRenderNode instances, which represent the tree of rendering operations; and a GskRenderer instance, which takes the render nodes and submits them (after potentially reordering and transforming them to a more appropriate representation) to the underlying graphic system.
2016-03-17 13:48:19 +00:00
API: Add gsk_renderer_realize_for_display() This makes realizing a renderer without a surface explicit. And more importantly, it allows passing a different display than the default one.
2024-01-07 09:00:38 +00:00
/**
* gsk_renderer_realize_for_display:
* @renderer: a `GskRenderer`
* @display: the `GdkDisplay` renderer will be used on
* @error: return location for an error
*
* Creates the resources needed by the @renderer to render the scene
* graph.
*
* Note that it is mandatory to call [method@Gsk.Renderer.unrealize] before
* destroying the renderer.
*
* Returns: Whether the renderer was successfully realized
*
* Since: 4.14
*/
gboolean
gsk_renderer_realize_for_display (GskRenderer *renderer,
GdkDisplay *display,
GError **error)
{
g_return_val_if_fail (GSK_IS_RENDERER (renderer), FALSE);
g_return_val_if_fail (!gsk_renderer_is_realized (renderer), FALSE);
g_return_val_if_fail (display == NULL || GDK_IS_DISPLAY (display), FALSE);
g_return_val_if_fail (error == NULL || *error == NULL, FALSE);
gsk: Fix some renderer gotchas unrealize() needs to clean up the surface that was set in realize(), and both need to emit property change notification.
2023-05-10 20:55:16 +00:00
API: Add gsk_renderer_realize_for_display() This makes realizing a renderer without a surface explicit. And more importantly, it allows passing a different display than the default one.
2024-01-07 09:00:38 +00:00
return gsk_renderer_do_realize (renderer, display, NULL, error);
Initial implementation of GSK rendering pipeline GSK is conceptually split into two scene graphs: * a simple rendering tree of operations * a complex set of logical layers The latter is built on the former, and adds convenience and high level API for application developers. The lower layer, though, is what gets transformed into the rendering pipeline, as it's simple and thus can be transformed into appropriate rendering commands with minimal state changes. The lower layer is also suitable for reuse from more complex higher layers, like the CSS machinery in GTK, without necessarily port those layers to the GSK high level API. This lower layer is based on GskRenderNode instances, which represent the tree of rendering operations; and a GskRenderer instance, which takes the render nodes and submits them (after potentially reordering and transforming them to a more appropriate representation) to the underlying graphic system.
2016-03-17 13:48:19 +00:00
}
/**
* gsk_renderer_unrealize:
gskrenderer: Add property annotations Connect properties, getters, and setters with annotations
2021-02-25 11:59:41 +00:00
* @renderer: a `GskRenderer`
Initial implementation of GSK rendering pipeline GSK is conceptually split into two scene graphs: * a simple rendering tree of operations * a complex set of logical layers The latter is built on the former, and adds convenience and high level API for application developers. The lower layer, though, is what gets transformed into the rendering pipeline, as it's simple and thus can be transformed into appropriate rendering commands with minimal state changes. The lower layer is also suitable for reuse from more complex higher layers, like the CSS machinery in GTK, without necessarily port those layers to the GSK high level API. This lower layer is based on GskRenderNode instances, which represent the tree of rendering operations; and a GskRenderer instance, which takes the render nodes and submits them (after potentially reordering and transforming them to a more appropriate representation) to the underlying graphic system.
2016-03-17 13:48:19 +00:00
*
* Releases all the resources created by gsk_renderer_realize().
*/
void
gsk_renderer_unrealize (GskRenderer *renderer)
{
GskRendererPrivate *priv = gsk_renderer_get_instance_private (renderer);
gsk: Fix some renderer gotchas unrealize() needs to clean up the surface that was set in realize(), and both need to emit property change notification.
2023-05-10 20:55:16 +00:00
gboolean has_surface;
Initial implementation of GSK rendering pipeline GSK is conceptually split into two scene graphs: * a simple rendering tree of operations * a complex set of logical layers The latter is built on the former, and adds convenience and high level API for application developers. The lower layer, though, is what gets transformed into the rendering pipeline, as it's simple and thus can be transformed into appropriate rendering commands with minimal state changes. The lower layer is also suitable for reuse from more complex higher layers, like the CSS machinery in GTK, without necessarily port those layers to the GSK high level API. This lower layer is based on GskRenderNode instances, which represent the tree of rendering operations; and a GskRenderer instance, which takes the render nodes and submits them (after potentially reordering and transforming them to a more appropriate representation) to the underlying graphic system.
2016-03-17 13:48:19 +00:00
g_return_if_fail (GSK_IS_RENDERER (renderer));
if (!priv->is_realized)
return;
gsk: Fix some renderer gotchas unrealize() needs to clean up the surface that was set in realize(), and both need to emit property change notification.
2023-05-10 20:55:16 +00:00
has_surface = priv->surface != NULL;
Initial implementation of GSK rendering pipeline GSK is conceptually split into two scene graphs: * a simple rendering tree of operations * a complex set of logical layers The latter is built on the former, and adds convenience and high level API for application developers. The lower layer, though, is what gets transformed into the rendering pipeline, as it's simple and thus can be transformed into appropriate rendering commands with minimal state changes. The lower layer is also suitable for reuse from more complex higher layers, like the CSS machinery in GTK, without necessarily port those layers to the GSK high level API. This lower layer is based on GskRenderNode instances, which represent the tree of rendering operations; and a GskRenderer instance, which takes the render nodes and submits them (after potentially reordering and transforming them to a more appropriate representation) to the underlying graphic system.
2016-03-17 13:48:19 +00:00
GSK_RENDERER_GET_CLASS (renderer)->unrealize (renderer);
gsk: Fix some renderer gotchas unrealize() needs to clean up the surface that was set in realize(), and both need to emit property change notification.
2023-05-10 20:55:16 +00:00
g_clear_object (&priv->surface);
renderer: Track the previous node ... and diff the previous node with the current one to determine the clip region. This doubles the work necessary to track clip regions, but the following commits will clean that up.
2018-03-28 13:43:43 +00:00
g_clear_pointer (&priv->prev_node, gsk_render_node_unref);
Initial implementation of GSK rendering pipeline GSK is conceptually split into two scene graphs: * a simple rendering tree of operations * a complex set of logical layers The latter is built on the former, and adds convenience and high level API for application developers. The lower layer, though, is what gets transformed into the rendering pipeline, as it's simple and thus can be transformed into appropriate rendering commands with minimal state changes. The lower layer is also suitable for reuse from more complex higher layers, like the CSS machinery in GTK, without necessarily port those layers to the GSK high level API. This lower layer is based on GskRenderNode instances, which represent the tree of rendering operations; and a GskRenderer instance, which takes the render nodes and submits them (after potentially reordering and transforming them to a more appropriate representation) to the underlying graphic system.
2016-03-17 13:48:19 +00:00
priv->is_realized = FALSE;
gsk: Fix some renderer gotchas unrealize() needs to clean up the surface that was set in realize(), and both need to emit property change notification.
2023-05-10 20:55:16 +00:00
g_object_notify (G_OBJECT (renderer), "realized");
if (has_surface)
g_object_notify (G_OBJECT (renderer), "surface");
Initial implementation of GSK rendering pipeline GSK is conceptually split into two scene graphs: * a simple rendering tree of operations * a complex set of logical layers The latter is built on the former, and adds convenience and high level API for application developers. The lower layer, though, is what gets transformed into the rendering pipeline, as it's simple and thus can be transformed into appropriate rendering commands with minimal state changes. The lower layer is also suitable for reuse from more complex higher layers, like the CSS machinery in GTK, without necessarily port those layers to the GSK high level API. This lower layer is based on GskRenderNode instances, which represent the tree of rendering operations; and a GskRenderer instance, which takes the render nodes and submits them (after potentially reordering and transforming them to a more appropriate representation) to the underlying graphic system.
2016-03-17 13:48:19 +00:00
}
gsk: Add gsk_renderer_render_texture() ... and implement it for the Cairo renderer. It's an API that instructs a renderer to render to a texture. So far this is mostly meant to be used for testing, but I could imagine it being useful for rendering DND icons.
2016-12-21 19:23:46 +00:00
/**
* gsk_renderer_render_texture:
gskrenderer: Add property annotations Connect properties, getters, and setters with annotations
2021-02-25 11:59:41 +00:00
* @renderer: a realized `GskRenderer`
* @root: a `GskRenderNode`
introspection: Stop using allow-none allow-none has been deprecated for a long time already. Instead use optional and nullable everywhere.
2021-05-19 11:24:34 +00:00
* @viewport: (nullable): the section to draw or %NULL to use @root's bounds
gsk: Add gsk_renderer_render_texture() ... and implement it for the Cairo renderer. It's an API that instructs a renderer to render to a texture. So far this is mostly meant to be used for testing, but I could imagine it being useful for rendering DND icons.
2016-12-21 19:23:46 +00:00
*
gskrenderer: Add property annotations Connect properties, getters, and setters with annotations
2021-02-25 11:59:41 +00:00
* Renders the scene graph, described by a tree of `GskRenderNode` instances,
* to a `GdkTexture`.
gsk: Add gsk_renderer_render_texture() ... and implement it for the Cairo renderer. It's an API that instructs a renderer to render to a texture. So far this is mostly meant to be used for testing, but I could imagine it being useful for rendering DND icons.
2016-12-21 19:23:46 +00:00
*
gskrenderer: Add property annotations Connect properties, getters, and setters with annotations
2021-02-25 11:59:41 +00:00
* The @renderer will acquire a reference on the `GskRenderNode` tree while
GskRenderer: Remove outdated documentation comment All render node trees are immutable
2018-03-31 11:52:19 +00:00
* the rendering is in progress.
gsk: Add gsk_renderer_render_texture() ... and implement it for the Cairo renderer. It's an API that instructs a renderer to render to a texture. So far this is mostly meant to be used for testing, but I could imagine it being useful for rendering DND icons.
2016-12-21 19:23:46 +00:00
*
gskrenderer: Add property annotations Connect properties, getters, and setters with annotations
2021-02-25 11:59:41 +00:00
* If you want to apply any transformations to @root, you should put it into a
gsk: Add gsk_renderer_render_texture() ... and implement it for the Cairo renderer. It's an API that instructs a renderer to render to a texture. So far this is mostly meant to be used for testing, but I could imagine it being useful for rendering DND icons.
2016-12-21 19:23:46 +00:00
* transform node and pass that node instead.
*
gskrenderer: Add property annotations Connect properties, getters, and setters with annotations
2021-02-25 11:59:41 +00:00
* Returns: (transfer full): a `GdkTexture` with the rendered contents of @root.
gsk: Add gsk_renderer_render_texture() ... and implement it for the Cairo renderer. It's an API that instructs a renderer to render to a texture. So far this is mostly meant to be used for testing, but I could imagine it being useful for rendering DND icons.
2016-12-21 19:23:46 +00:00
*/
GskTexture => GdkTexture We want this thing to replace GdkPixbuf, so it has to live in GDK.
2017-11-02 20:39:00 +00:00
GdkTexture *
gsk: Add gsk_renderer_render_texture() ... and implement it for the Cairo renderer. It's an API that instructs a renderer to render to a texture. So far this is mostly meant to be used for testing, but I could imagine it being useful for rendering DND icons.
2016-12-21 19:23:46 +00:00
gsk_renderer_render_texture (GskRenderer *renderer,
GskRenderNode *root,
const graphene_rect_t *viewport)
{
GskRendererPrivate *priv = gsk_renderer_get_instance_private (renderer);
graphene_rect_t real_viewport;
GskTexture => GdkTexture We want this thing to replace GdkPixbuf, so it has to live in GDK.
2017-11-02 20:39:00 +00:00
GdkTexture *texture;
gsk: Add gsk_renderer_render_texture() ... and implement it for the Cairo renderer. It's an API that instructs a renderer to render to a texture. So far this is mostly meant to be used for testing, but I could imagine it being useful for rendering DND icons.
2016-12-21 19:23:46 +00:00
g_return_val_if_fail (GSK_IS_RENDERER (renderer), NULL);
g_return_val_if_fail (priv->is_realized, NULL);
g_return_val_if_fail (GSK_IS_RENDER_NODE (root), NULL);
if (viewport == NULL)
{
gsk_render_node_get_bounds (root, &real_viewport);
viewport = &real_viewport;
}
renderer: return_if_fail() if the given texture size is 0 All renderers SEGV currently when that happens.
2023-05-20 23:27:09 +00:00
g_return_val_if_fail (viewport->size.width > 0, NULL);
g_return_val_if_fail (viewport->size.height > 0, NULL);
gsk: Add gsk_renderer_render_texture() ... and implement it for the Cairo renderer. It's an API that instructs a renderer to render to a texture. So far this is mostly meant to be used for testing, but I could imagine it being useful for rendering DND icons.
2016-12-21 19:23:46 +00:00
texture = GSK_RENDERER_GET_CLASS (renderer)->render_texture (renderer, root, viewport);
return texture;
}
Initial implementation of GSK rendering pipeline GSK is conceptually split into two scene graphs: * a simple rendering tree of operations * a complex set of logical layers The latter is built on the former, and adds convenience and high level API for application developers. The lower layer, though, is what gets transformed into the rendering pipeline, as it's simple and thus can be transformed into appropriate rendering commands with minimal state changes. The lower layer is also suitable for reuse from more complex higher layers, like the CSS machinery in GTK, without necessarily port those layers to the GSK high level API. This lower layer is based on GskRenderNode instances, which represent the tree of rendering operations; and a GskRenderer instance, which takes the render nodes and submits them (after potentially reordering and transforming them to a more appropriate representation) to the underlying graphic system.
2016-03-17 13:48:19 +00:00
/**
* gsk_renderer_render:
gsk: Allow gsk_renderer_realize (renderer, NULL, NULL) That way, we can use renderers without surfaces.
2021-10-20 18:30:08 +00:00
* @renderer: a realized `GskRenderer`
gskrenderer: Add property annotations Connect properties, getters, and setters with annotations
2021-02-25 11:59:41 +00:00
* @root: a `GskRenderNode`
* @region: (nullable): the `cairo_region_t` that must be redrawn or %NULL
Documentation fixes Mostly fixing up indentation of continuation lines, and other small cleanups.
2021-05-18 21:05:26 +00:00
* for the whole window
gsk: Rework GskRenderer and GskRenderNode semantics This commit changes the way GskRenderer and GskRenderNode interact and are meant to be used. GskRenderNode should represent a transient tree of rendering nodes, which are submitted to the GskRenderer at render time; this allows the renderer to take ownership of the render tree. Once the toolkit and application code have finished assembling it, the render tree ownership is transferred to the renderer.
2016-06-22 16:30:36 +00:00
*
gsk: Allow gsk_renderer_realize (renderer, NULL, NULL) That way, we can use renderers without surfaces.
2021-10-20 18:30:08 +00:00
* Renders the scene graph, described by a tree of `GskRenderNode` instances
* to the renderer's surface, ensuring that the given @region gets redrawn.
*
* If the renderer has no associated surface, this function does nothing.
gsk: Fold gsk_renderer_begin_draw_frame() into renderer It doesn't need to be exported anymore. As a side effect, the inspector no longer has any information about the render region, so remove the code that was taking care of that.
2018-03-27 23:29:39 +00:00
*
* Renderers must ensure that changes of the contents given by the @root
* node as well as the area given by @region are redrawn. They are however
* free to not redraw any pixel outside of @region if they can guarantee that
* it didn't change.
Initial implementation of GSK rendering pipeline GSK is conceptually split into two scene graphs: * a simple rendering tree of operations * a complex set of logical layers The latter is built on the former, and adds convenience and high level API for application developers. The lower layer, though, is what gets transformed into the rendering pipeline, as it's simple and thus can be transformed into appropriate rendering commands with minimal state changes. The lower layer is also suitable for reuse from more complex higher layers, like the CSS machinery in GTK, without necessarily port those layers to the GSK high level API. This lower layer is based on GskRenderNode instances, which represent the tree of rendering operations; and a GskRenderer instance, which takes the render nodes and submits them (after potentially reordering and transforming them to a more appropriate representation) to the underlying graphic system.
2016-03-17 13:48:19 +00:00
*
gskrenderer: Add property annotations Connect properties, getters, and setters with annotations
2021-02-25 11:59:41 +00:00
* The @renderer will acquire a reference on the `GskRenderNode` tree while
gsk: Drop gsk_render_node_make_immutable, nodes are always immutable
2016-12-21 10:00:18 +00:00
* the rendering is in progress.
Initial implementation of GSK rendering pipeline GSK is conceptually split into two scene graphs: * a simple rendering tree of operations * a complex set of logical layers The latter is built on the former, and adds convenience and high level API for application developers. The lower layer, though, is what gets transformed into the rendering pipeline, as it's simple and thus can be transformed into appropriate rendering commands with minimal state changes. The lower layer is also suitable for reuse from more complex higher layers, like the CSS machinery in GTK, without necessarily port those layers to the GSK high level API. This lower layer is based on GskRenderNode instances, which represent the tree of rendering operations; and a GskRenderer instance, which takes the render nodes and submits them (after potentially reordering and transforming them to a more appropriate representation) to the underlying graphic system.
2016-03-17 13:48:19 +00:00
*/
void
gsk: Fold gsk_renderer_begin_draw_frame() into renderer It doesn't need to be exported anymore. As a side effect, the inspector no longer has any information about the render region, so remove the code that was taking care of that.
2018-03-27 23:29:39 +00:00
gsk_renderer_render (GskRenderer *renderer,
GskRenderNode *root,
const cairo_region_t *region)
Initial implementation of GSK rendering pipeline GSK is conceptually split into two scene graphs: * a simple rendering tree of operations * a complex set of logical layers The latter is built on the former, and adds convenience and high level API for application developers. The lower layer, though, is what gets transformed into the rendering pipeline, as it's simple and thus can be transformed into appropriate rendering commands with minimal state changes. The lower layer is also suitable for reuse from more complex higher layers, like the CSS machinery in GTK, without necessarily port those layers to the GSK high level API. This lower layer is based on GskRenderNode instances, which represent the tree of rendering operations; and a GskRenderer instance, which takes the render nodes and submits them (after potentially reordering and transforming them to a more appropriate representation) to the underlying graphic system.
2016-03-17 13:48:19 +00:00
{
GskRendererPrivate *priv = gsk_renderer_get_instance_private (renderer);
renderer: Add a supports_offload flag This flag must be set when creating the class or offloading will be disabled for this renderer. Set that flag for the GL renderer. Fixes the Cairo and Vulkan renderer not showing Video.
2023-11-14 11:50:12 +00:00
GskRendererClass *renderer_class;
renderer: Track the previous node ... and diff the previous node with the current one to determine the clip region. This doubles the work necessary to track clip regions, but the following commits will clean that up.
2018-03-28 13:43:43 +00:00
cairo_region_t *clip;
renderer: Add a supports_offload flag This flag must be set when creating the class or offloading will be disabled for this renderer. Set that flag for the GL renderer. Fixes the Cairo and Vulkan renderer not showing Video.
2023-11-14 11:50:12 +00:00
GskOffload *offload;
Initial implementation of GSK rendering pipeline GSK is conceptually split into two scene graphs: * a simple rendering tree of operations * a complex set of logical layers The latter is built on the former, and adds convenience and high level API for application developers. The lower layer, though, is what gets transformed into the rendering pipeline, as it's simple and thus can be transformed into appropriate rendering commands with minimal state changes. The lower layer is also suitable for reuse from more complex higher layers, like the CSS machinery in GTK, without necessarily port those layers to the GSK high level API. This lower layer is based on GskRenderNode instances, which represent the tree of rendering operations; and a GskRenderer instance, which takes the render nodes and submits them (after potentially reordering and transforming them to a more appropriate representation) to the underlying graphic system.
2016-03-17 13:48:19 +00:00
g_return_if_fail (GSK_IS_RENDERER (renderer));
g_return_if_fail (priv->is_realized);
gsk: Rework GskRenderer and GskRenderNode semantics This commit changes the way GskRenderer and GskRenderNode interact and are meant to be used. GskRenderNode should represent a transient tree of rendering nodes, which are submitted to the GskRenderer at render time; this allows the renderer to take ownership of the render tree. Once the toolkit and application code have finished assembling it, the render tree ownership is transferred to the renderer.
2016-06-22 16:30:36 +00:00
g_return_if_fail (GSK_IS_RENDER_NODE (root));
Initial implementation of GSK rendering pipeline GSK is conceptually split into two scene graphs: * a simple rendering tree of operations * a complex set of logical layers The latter is built on the former, and adds convenience and high level API for application developers. The lower layer, though, is what gets transformed into the rendering pipeline, as it's simple and thus can be transformed into appropriate rendering commands with minimal state changes. The lower layer is also suitable for reuse from more complex higher layers, like the CSS machinery in GTK, without necessarily port those layers to the GSK high level API. This lower layer is based on GskRenderNode instances, which represent the tree of rendering operations; and a GskRenderer instance, which takes the render nodes and submits them (after potentially reordering and transforming them to a more appropriate representation) to the underlying graphic system.
2016-03-17 13:48:19 +00:00
gsk: Allow gsk_renderer_realize (renderer, NULL, NULL) That way, we can use renderers without surfaces.
2021-10-20 18:30:08 +00:00
if (priv->surface == NULL)
return;
renderer: Add a supports_offload flag This flag must be set when creating the class or offloading will be disabled for this renderer. Set that flag for the GL renderer. Fixes the Cairo and Vulkan renderer not showing Video.
2023-11-14 11:50:12 +00:00
renderer_class = GSK_RENDERER_GET_CLASS (renderer);
gsk: Prepare subsurface offload Use a GskOffloadInfo to update subsurfaces (and collect info about them). Pass that info to both the diff and the render vfuncs.
2023-10-31 23:19:32 +00:00
offload: Change the way we compute damage regions Instead of relying on diffing subsurface nodes, we track damage generated by offloaded contents inside GskOffload. There are 3 stages a subsurface node can be in: 1. not offloaded Drawing is done by the renderer 2. offloaded above The renderer draws nothing 3. offloaded below The renderer needs to punch a hole. Whenever the stage changes, we need to repaint. And that can happen without the subsurface's contents changing, like when a widget is put above the subsurface and it needs to to go from offloaded above to below. So we now recruit GskOffload for tracking these changes, instead of relying on the subsurface diffing. But we still need the subsurface diffing code to work for the non-offloaded case, because then the offloading code is not used. So we keep using it whenever that happens. Not that when a subsurface transitions between being offloaded and not being offloaded, we may diff it twice - once in the offload code and once in the node diffing - but that shouldn't matter.
2024-02-10 05:32:20 +00:00
clip = cairo_region_copy (region);
Change the offload-disable flag Move this from GSK_DEBUG=offload-disable to GDK_DISABLE=offload.
2024-08-19 20:20:11 +00:00
if (renderer_class->supports_offload && gdk_has_feature (GDK_FEATURE_OFFLOAD))
offload: Change the way we compute damage regions Instead of relying on diffing subsurface nodes, we track damage generated by offloaded contents inside GskOffload. There are 3 stages a subsurface node can be in: 1. not offloaded Drawing is done by the renderer 2. offloaded above The renderer draws nothing 3. offloaded below The renderer needs to punch a hole. Whenever the stage changes, we need to repaint. And that can happen without the subsurface's contents changing, like when a widget is put above the subsurface and it needs to to go from offloaded above to below. So we now recruit GskOffload for tracking these changes, instead of relying on the subsurface diffing. But we still need the subsurface diffing code to work for the non-offloaded case, because then the offloading code is not used. So we keep using it whenever that happens. Not that when a subsurface transitions between being offloaded and not being offloaded, we may diff it twice - once in the offload code and once in the node diffing - but that shouldn't matter.
2024-02-10 05:32:20 +00:00
offload = gsk_offload_new (priv->surface, root, clip);
renderer: Add a supports_offload flag This flag must be set when creating the class or offloading will be disabled for this renderer. Set that flag for the GL renderer. Fixes the Cairo and Vulkan renderer not showing Video.
2023-11-14 11:50:12 +00:00
else
offload = NULL;
gsk: Prepare subsurface offload Use a GskOffloadInfo to update subsurfaces (and collect info about them). Pass that info to both the diff and the render vfuncs.
2023-10-31 23:19:32 +00:00
renderer: Track the previous node ... and diff the previous node with the current one to determine the clip region. This doubles the work necessary to track clip regions, but the following commits will clean that up.
2018-03-28 13:43:43 +00:00
if (region == NULL || priv->prev_node == NULL || GSK_RENDERER_DEBUG_CHECK (renderer, FULL_REDRAW))
gsk: Fold gsk_renderer_begin_draw_frame() into renderer It doesn't need to be exported anymore. As a side effect, the inspector no longer has any information about the render region, so remove the code that was taking care of that.
2018-03-27 23:29:39 +00:00
{
offload: Change the way we compute damage regions Instead of relying on diffing subsurface nodes, we track damage generated by offloaded contents inside GskOffload. There are 3 stages a subsurface node can be in: 1. not offloaded Drawing is done by the renderer 2. offloaded above The renderer draws nothing 3. offloaded below The renderer needs to punch a hole. Whenever the stage changes, we need to repaint. And that can happen without the subsurface's contents changing, like when a widget is put above the subsurface and it needs to to go from offloaded above to below. So we now recruit GskOffload for tracking these changes, instead of relying on the subsurface diffing. But we still need the subsurface diffing code to work for the non-offloaded case, because then the offloading code is not used. So we keep using it whenever that happens. Not that when a subsurface transitions between being offloaded and not being offloaded, we may diff it twice - once in the offload code and once in the node diffing - but that shouldn't matter.
2024-02-10 05:32:20 +00:00
cairo_region_union_rectangle (clip,
&(GdkRectangle) {
0, 0,
gdk_surface_get_width (priv->surface),
gdk_surface_get_height (priv->surface)
});
gsk: Fold gsk_renderer_begin_draw_frame() into renderer It doesn't need to be exported anymore. As a side effect, the inspector no longer has any information about the render region, so remove the code that was taking care of that.
2018-03-27 23:29:39 +00:00
}
else
gsk: move begin/end_frame vfuncs into the renderers
2018-03-28 13:01:34 +00:00
{
Rework diffing one more time Pass the surface along. We need it to identify the inspector case in gsk_subsurface_node_diff.
2024-02-11 20:53:37 +00:00
gsk_render_node_diff (priv->prev_node, root, &(GskDiffData) { clip, priv->surface });
gsk: move begin/end_frame vfuncs into the renderers
2018-03-28 13:01:34 +00:00
}
Initial implementation of GSK rendering pipeline GSK is conceptually split into two scene graphs: * a simple rendering tree of operations * a complex set of logical layers The latter is built on the former, and adds convenience and high level API for application developers. The lower layer, though, is what gets transformed into the rendering pipeline, as it's simple and thus can be transformed into appropriate rendering commands with minimal state changes. The lower layer is also suitable for reuse from more complex higher layers, like the CSS machinery in GTK, without necessarily port those layers to the GSK high level API. This lower layer is based on GskRenderNode instances, which represent the tree of rendering operations; and a GskRenderer instance, which takes the render nodes and submits them (after potentially reordering and transforming them to a more appropriate representation) to the underlying graphic system.
2016-03-17 13:48:19 +00:00
renderer: Remove offload argument from render() It turns out it's not needed, because all relevant information for subsurfaces is already available by querying the subsurface itself.
2023-11-14 20:45:47 +00:00
renderer_class->render (renderer, root, clip);
renderer: Track the previous node ... and diff the previous node with the current one to determine the clip region. This doubles the work necessary to track clip regions, but the following commits will clean that up.
2018-03-28 13:43:43 +00:00
g_clear_pointer (&priv->prev_node, gsk_render_node_unref);
GskRenderer: Plug a memory leak
2018-04-14 10:37:19 +00:00
cairo_region_destroy (clip);
renderer: Don't crash with offload disabled
2023-11-14 11:49:35 +00:00
g_clear_pointer (&offload, gsk_offload_free);
renderer: Remove priv->root_node It's not used anywhere.
2023-11-14 12:25:30 +00:00
priv->prev_node = gsk_render_node_ref (root);
Initial implementation of GSK rendering pipeline GSK is conceptually split into two scene graphs: * a simple rendering tree of operations * a complex set of logical layers The latter is built on the former, and adds convenience and high level API for application developers. The lower layer, though, is what gets transformed into the rendering pipeline, as it's simple and thus can be transformed into appropriate rendering commands with minimal state changes. The lower layer is also suitable for reuse from more complex higher layers, like the CSS machinery in GTK, without necessarily port those layers to the GSK high level API. This lower layer is based on GskRenderNode instances, which represent the tree of rendering operations; and a GskRenderer instance, which takes the render nodes and submits them (after potentially reordering and transforming them to a more appropriate representation) to the underlying graphic system.
2016-03-17 13:48:19 +00:00
}
gsk: Add GskProfiler to GskRenderer The profiler instance is per-renderer, and is accesible to implementations.
2016-08-03 15:51:21 +00:00
/*< private >
* gsk_renderer_get_profiler:
gsk: Clean up docs syntax Replace leftover gtk-doc syntax (#Type) with backquotes.
2021-05-20 03:40:54 +00:00
* @renderer: a `GskRenderer`
gsk: Add GskProfiler to GskRenderer The profiler instance is per-renderer, and is accesible to implementations.
2016-08-03 15:51:21 +00:00
*
gsk: Clean up docs syntax Replace leftover gtk-doc syntax (#Type) with backquotes.
2021-05-20 03:40:54 +00:00
* Retrieves a pointer to the `GskProfiler` instance of the renderer.
gsk: Add GskProfiler to GskRenderer The profiler instance is per-renderer, and is accesible to implementations.
2016-08-03 15:51:21 +00:00
*
* Returns: (transfer none): the profiler
*/
GskProfiler *
gsk_renderer_get_profiler (GskRenderer *renderer)
{
GskRendererPrivate *priv = gsk_renderer_get_instance_private (renderer);
g_return_val_if_fail (GSK_IS_RENDERER (renderer), NULL);
return priv->profiler;
}
Allow custom renderer for the inspector If you set GTK_INSPECTOR_RENDERER to the same type of values that GSK_RENDERER takes this can change the renderer used for the inspector. This is useful if you're debugging one renderer and don't want to affect the inspector.
2017-03-17 15:12:45 +00:00
static GType
get_renderer_for_name (const char *renderer_name)
{
if (renderer_name == NULL)
return G_TYPE_INVALID;
gsk: Improve GSK_RENDERER behavior 1. Include the broadway renderer (so we can test it properly fails on Wayland or X11) 2. List all potential renderers, print useful information when Vulkan is not compiled in instea dof omitting it 3. Improve docs
2018-05-07 14:45:32 +00:00
#ifdef GDK_WINDOWING_BROADWAY
else if (g_ascii_strcasecmp (renderer_name, "broadway") == 0)
return GSK_TYPE_BROADWAY_RENDERER;
#endif
Allow custom renderer for the inspector If you set GTK_INSPECTOR_RENDERER to the same type of values that GSK_RENDERER takes this can change the renderer used for the inspector. This is useful if you're debugging one renderer and don't want to affect the inspector.
2017-03-17 15:12:45 +00:00
else if (g_ascii_strcasecmp (renderer_name, "cairo") == 0)
return GSK_TYPE_CAIRO_RENDERER;
gsk: Make ngl the default OpenGL renderer We will keep the original GL renderer around for a while, to have an alternative. But we want to get wider testing of the new renderer.
2021-03-18 03:27:41 +00:00
else if (g_ascii_strcasecmp (renderer_name, "opengl") == 0 ||
Rename ngl to gl We have only one gl renderer now, and it is a bit odd for it not be called gl.
2021-10-07 03:15:25 +00:00
g_ascii_strcasecmp (renderer_name, "gl") == 0)
return GSK_TYPE_GL_RENDERER;
gsk: Add new renderers to the GSK_RENDERER env var Use: "ngl" for the new GL renderer "vulkan" for the new Vulkan renderer
2023-08-13 02:31:28 +00:00
else if (g_ascii_strcasecmp (renderer_name, "ngl") == 0)
return gsk_ngl_renderer_get_type ();
#ifdef GDK_RENDERING_VULKAN
else if (g_ascii_strcasecmp (renderer_name, "vulkan") == 0)
return GSK_TYPE_VULKAN_RENDERER;
#endif
Allow custom renderer for the inspector If you set GTK_INSPECTOR_RENDERER to the same type of values that GSK_RENDERER takes this can change the renderer used for the inspector. This is useful if you're debugging one renderer and don't want to affect the inspector.
2017-03-17 15:12:45 +00:00
else if (g_ascii_strcasecmp (renderer_name, "help") == 0)
{
g_print ("Supported arguments for GSK_RENDERER environment variable:\n");
gsk: Improve GSK_RENDERER behavior 1. Include the broadway renderer (so we can test it properly fails on Wayland or X11) 2. List all potential renderers, print useful information when Vulkan is not compiled in instea dof omitting it 3. Improve docs
2018-05-07 14:45:32 +00:00
#ifdef GDK_WINDOWING_BROADWAY
gsk: Add new renderers to the GSK_RENDERER env var Use: "ngl" for the new GL renderer "vulkan" for the new Vulkan renderer
2023-08-13 02:31:28 +00:00
g_print (" broadway - Use the Broadway specific renderer\n");
gsk: Improve GSK_RENDERER behavior 1. Include the broadway renderer (so we can test it properly fails on Wayland or X11) 2. List all potential renderers, print useful information when Vulkan is not compiled in instea dof omitting it 3. Improve docs
2018-05-07 14:45:32 +00:00
#else
gsk: Add new renderers to the GSK_RENDERER env var Use: "ngl" for the new GL renderer "vulkan" for the new Vulkan renderer
2023-08-13 02:31:28 +00:00
g_print (" broadway - Disabled during GTK build\n");
gsk: Improve GSK_RENDERER behavior 1. Include the broadway renderer (so we can test it properly fails on Wayland or X11) 2. List all potential renderers, print useful information when Vulkan is not compiled in instea dof omitting it 3. Improve docs
2018-05-07 14:45:32 +00:00
#endif
Allow custom renderer for the inspector If you set GTK_INSPECTOR_RENDERER to the same type of values that GSK_RENDERER takes this can change the renderer used for the inspector. This is useful if you're debugging one renderer and don't want to affect the inspector.
2017-03-17 15:12:45 +00:00
g_print (" cairo - Use the Cairo fallback renderer\n");
Rename ngl to gl We have only one gl renderer now, and it is a bit odd for it not be called gl.
2021-10-07 03:15:25 +00:00
g_print (" opengl - Use the OpenGL renderer\n");
g_print (" gl - Use the OpenGL renderer\n");
gsk: Add new renderers to the GSK_RENDERER env var Use: "ngl" for the new GL renderer "vulkan" for the new Vulkan renderer
2023-08-13 02:31:28 +00:00
g_print (" ngl - Use the new OpenGL renderer\n");
#ifdef GDK_RENDERING_VULKAN
g_print (" vulkan - Use the Vulkan renderer\n");
#else
g_print (" vulkan - Disabled during GTK build\n");
#endif
Allow custom renderer for the inspector If you set GTK_INSPECTOR_RENDERER to the same type of values that GSK_RENDERER takes this can change the renderer used for the inspector. This is useful if you're debugging one renderer and don't want to affect the inspector.
2017-03-17 15:12:45 +00:00
g_print (" help - Print this help\n\n");
g_print ("Other arguments will cause a warning and be ignored.\n");
}
else
{
g_warning ("Unrecognized renderer \"%s\". Try GSK_RENDERER=help", renderer_name);
}
return G_TYPE_INVALID;
}
static GType
Continue renaming window to surface This renames a lot of arguments, local variables and functions.
2018-03-21 10:49:14 +00:00
get_renderer_for_display (GdkSurface *surface)
Allow custom renderer for the inspector If you set GTK_INSPECTOR_RENDERER to the same type of values that GSK_RENDERER takes this can change the renderer used for the inspector. This is useful if you're debugging one renderer and don't want to affect the inspector.
2017-03-17 15:12:45 +00:00
{
Continue renaming window to surface This renames a lot of arguments, local variables and functions.
2018-03-21 10:49:14 +00:00
GdkDisplay *display = gdk_surface_get_display (surface);
Allow custom renderer for the inspector If you set GTK_INSPECTOR_RENDERER to the same type of values that GSK_RENDERER takes this can change the renderer used for the inspector. This is useful if you're debugging one renderer and don't want to affect the inspector.
2017-03-17 15:12:45 +00:00
const char *renderer_name;
GdkRenderer: Fix a compiler warning
2017-03-19 13:26:02 +00:00
renderer_name = g_object_get_data (G_OBJECT (display), "gsk-renderer");
Allow custom renderer for the inspector If you set GTK_INSPECTOR_RENDERER to the same type of values that GSK_RENDERER takes this can change the renderer used for the inspector. This is useful if you're debugging one renderer and don't want to affect the inspector.
2017-03-17 15:12:45 +00:00
return get_renderer_for_name (renderer_name);
}
gsk: Add gsk_renderer_new_for_window() and remove gsk_renderer_get_for_display(). This new function returns a realized renderer. Because of that, GSK can catch failures to realize, destroy the renderer and try another one. Or in short: I can finally use GTK on Weston with the nvidia binary drivers again. Signed-off-by: Emmanuele Bassi <ebassi@gnome.org>
2016-11-29 03:27:21 +00:00
static GType
Continue renaming window to surface This renames a lot of arguments, local variables and functions.
2018-03-21 10:49:14 +00:00
get_renderer_for_env_var (GdkSurface *surface)
Initial implementation of GSK rendering pipeline GSK is conceptually split into two scene graphs: * a simple rendering tree of operations * a complex set of logical layers The latter is built on the former, and adds convenience and high level API for application developers. The lower layer, though, is what gets transformed into the rendering pipeline, as it's simple and thus can be transformed into appropriate rendering commands with minimal state changes. The lower layer is also suitable for reuse from more complex higher layers, like the CSS machinery in GTK, without necessarily port those layers to the GSK high level API. This lower layer is based on GskRenderNode instances, which represent the tree of rendering operations; and a GskRenderer instance, which takes the render nodes and submits them (after potentially reordering and transforming them to a more appropriate representation) to the underlying graphic system.
2016-03-17 13:48:19 +00:00
{
gsk: Add debug spew to renderer selection Reshuffle things a bit and make GSK_DEBUG=renderer print out more information about why renderers were skipped or selected.
2024-04-29 14:01:34 +00:00
static GType env_var_type = G_TYPE_INVALID;
Initial implementation of GSK rendering pipeline GSK is conceptually split into two scene graphs: * a simple rendering tree of operations * a complex set of logical layers The latter is built on the former, and adds convenience and high level API for application developers. The lower layer, though, is what gets transformed into the rendering pipeline, as it's simple and thus can be transformed into appropriate rendering commands with minimal state changes. The lower layer is also suitable for reuse from more complex higher layers, like the CSS machinery in GTK, without necessarily port those layers to the GSK high level API. This lower layer is based on GskRenderNode instances, which represent the tree of rendering operations; and a GskRenderer instance, which takes the render nodes and submits them (after potentially reordering and transforming them to a more appropriate representation) to the underlying graphic system.
2016-03-17 13:48:19 +00:00
gsk: Add debug spew to renderer selection Reshuffle things a bit and make GSK_DEBUG=renderer print out more information about why renderers were skipped or selected.
2024-04-29 14:01:34 +00:00
if (env_var_type == G_TYPE_INVALID)
Initial implementation of GSK rendering pipeline GSK is conceptually split into two scene graphs: * a simple rendering tree of operations * a complex set of logical layers The latter is built on the former, and adds convenience and high level API for application developers. The lower layer, though, is what gets transformed into the rendering pipeline, as it's simple and thus can be transformed into appropriate rendering commands with minimal state changes. The lower layer is also suitable for reuse from more complex higher layers, like the CSS machinery in GTK, without necessarily port those layers to the GSK high level API. This lower layer is based on GskRenderNode instances, which represent the tree of rendering operations; and a GskRenderer instance, which takes the render nodes and submits them (after potentially reordering and transforming them to a more appropriate representation) to the underlying graphic system.
2016-03-17 13:48:19 +00:00
{
gsk: Change GSK_USE_SOFTWARE env var to GSK_RENDERER This way, we can use the variable as more than a boolean flag. This will be useful for Vulkan or D3D renderers.
2016-11-29 12:36:31 +00:00
const char *renderer_name = g_getenv ("GSK_RENDERER");
Allow custom renderer for the inspector If you set GTK_INSPECTOR_RENDERER to the same type of values that GSK_RENDERER takes this can change the renderer used for the inspector. This is useful if you're debugging one renderer and don't want to affect the inspector.
2017-03-17 15:12:45 +00:00
env_var_type = get_renderer_for_name (renderer_name);
gsk: Add debug spew to renderer selection Reshuffle things a bit and make GSK_DEBUG=renderer print out more information about why renderers were skipped or selected.
2024-04-29 14:01:34 +00:00
if (env_var_type != G_TYPE_INVALID)
GSK_DEBUG (RENDERER,
"Environment variable GSK_RENDERER=%s set, trying %s",
renderer_name,
g_type_name (env_var_type));
Initial implementation of GSK rendering pipeline GSK is conceptually split into two scene graphs: * a simple rendering tree of operations * a complex set of logical layers The latter is built on the former, and adds convenience and high level API for application developers. The lower layer, though, is what gets transformed into the rendering pipeline, as it's simple and thus can be transformed into appropriate rendering commands with minimal state changes. The lower layer is also suitable for reuse from more complex higher layers, like the CSS machinery in GTK, without necessarily port those layers to the GSK high level API. This lower layer is based on GskRenderNode instances, which represent the tree of rendering operations; and a GskRenderer instance, which takes the render nodes and submits them (after potentially reordering and transforming them to a more appropriate representation) to the underlying graphic system.
2016-03-17 13:48:19 +00:00
}
gsk: Change GSK_USE_SOFTWARE env var to GSK_RENDERER This way, we can use the variable as more than a boolean flag. This will be useful for Vulkan or D3D renderers.
2016-11-29 12:36:31 +00:00
return env_var_type;
gsk: Add gsk_renderer_new_for_window() and remove gsk_renderer_get_for_display(). This new function returns a realized renderer. Because of that, GSK can catch failures to realize, destroy the renderer and try another one. Or in short: I can finally use GTK on Weston with the nvidia binary drivers again. Signed-off-by: Emmanuele Bassi <ebassi@gnome.org>
2016-11-29 03:27:21 +00:00
}
static GType
Continue renaming window to surface This renames a lot of arguments, local variables and functions.
2018-03-21 10:49:14 +00:00
get_renderer_for_backend (GdkSurface *surface)
gsk: Add gsk_renderer_new_for_window() and remove gsk_renderer_get_for_display(). This new function returns a realized renderer. Because of that, GSK can catch failures to realize, destroy the renderer and try another one. Or in short: I can finally use GTK on Weston with the nvidia binary drivers again. Signed-off-by: Emmanuele Bassi <ebassi@gnome.org>
2016-11-29 03:27:21 +00:00
{
broadway: Add GskBroadwayRenderer This is a custom renderer for broadway windows, although at the moment it doesn't really do anything other than the old cairo fallbacks.
2017-11-17 11:04:02 +00:00
#ifdef GDK_WINDOWING_BROADWAY
Continue renaming window to surface This renames a lot of arguments, local variables and functions.
2018-03-21 10:49:14 +00:00
if (GDK_IS_BROADWAY_SURFACE (surface))
broadway: Add GskBroadwayRenderer This is a custom renderer for broadway windows, although at the moment it doesn't really do anything other than the old cairo fallbacks.
2017-11-17 11:04:02 +00:00
return GSK_TYPE_BROADWAY_RENDERER;
#endif
Initial implementation of GSK rendering pipeline GSK is conceptually split into two scene graphs: * a simple rendering tree of operations * a complex set of logical layers The latter is built on the former, and adds convenience and high level API for application developers. The lower layer, though, is what gets transformed into the rendering pipeline, as it's simple and thus can be transformed into appropriate rendering commands with minimal state changes. The lower layer is also suitable for reuse from more complex higher layers, like the CSS machinery in GTK, without necessarily port those layers to the GSK high level API. This lower layer is based on GskRenderNode instances, which represent the tree of rendering operations; and a GskRenderer instance, which takes the render nodes and submits them (after potentially reordering and transforming them to a more appropriate representation) to the underlying graphic system.
2016-03-17 13:48:19 +00:00
gsk: Add gsk_renderer_new_for_window() and remove gsk_renderer_get_for_display(). This new function returns a realized renderer. Because of that, GSK can catch failures to realize, destroy the renderer and try another one. Or in short: I can finally use GTK on Weston with the nvidia binary drivers again. Signed-off-by: Emmanuele Bassi <ebassi@gnome.org>
2016-11-29 03:27:21 +00:00
return G_TYPE_INVALID;
}
gsk: Don't use gpu renderers with llvmpipe Unless the renderer has been explicitly selected via the GSK_RENDERER environment variable, don't use it with llvmpipe. It is important that we allow explicit setting to override this, so we can continue to use ngl in ci, where we don't have hw and want to test with llvmpipe. This should address many of the "performance is terrible in GNOME OS" complaints that are coming from people running in VMs, etc.
2024-02-12 19:16:09 +00:00
static gboolean
gsk: Add debug spew to renderer selection Reshuffle things a bit and make GSK_DEBUG=renderer print out more information about why renderers were skipped or selected.
2024-04-29 14:01:34 +00:00
gl_supported_platform (GdkSurface *surface,
GType renderer_type,
gboolean as_fallback)
gsk: Don't use gpu renderers with llvmpipe Unless the renderer has been explicitly selected via the GSK_RENDERER environment variable, don't use it with llvmpipe. It is important that we allow explicit setting to override this, so we can continue to use ngl in ci, where we don't have hw and want to test with llvmpipe. This should address many of the "performance is terrible in GNOME OS" complaints that are coming from people running in VMs, etc.
2024-02-12 19:16:09 +00:00
{
GdkDisplay *display = gdk_surface_get_display (surface);
GdkGLContext *context;
gsk: Add debug spew to renderer selection Reshuffle things a bit and make GSK_DEBUG=renderer print out more information about why renderers were skipped or selected.
2024-04-29 14:01:34 +00:00
GError *error = NULL;
gsk: Don't use gpu renderers with llvmpipe Unless the renderer has been explicitly selected via the GSK_RENDERER environment variable, don't use it with llvmpipe. It is important that we allow explicit setting to override this, so we can continue to use ngl in ci, where we don't have hw and want to test with llvmpipe. This should address many of the "performance is terrible in GNOME OS" complaints that are coming from people running in VMs, etc.
2024-02-12 19:16:09 +00:00
gsk: Add debug spew to renderer selection Reshuffle things a bit and make GSK_DEBUG=renderer print out more information about why renderers were skipped or selected.
2024-04-29 14:01:34 +00:00
if (!gdk_display_prepare_gl (display, &error))
{
if (!as_fallback)
GSK_DEBUG (RENDERER, "Not using GL: %s", error->message);
g_clear_error (&error);
return FALSE;
}
if (as_fallback)
return TRUE;
gsk: Don't use gpu renderers with llvmpipe Unless the renderer has been explicitly selected via the GSK_RENDERER environment variable, don't use it with llvmpipe. It is important that we allow explicit setting to override this, so we can continue to use ngl in ci, where we don't have hw and want to test with llvmpipe. This should address many of the "performance is terrible in GNOME OS" complaints that are coming from people running in VMs, etc.
2024-02-12 19:16:09 +00:00
context = gdk_display_get_gl_context (display);
gdk_gl_context_make_current (context);
gsk: Add debug spew to renderer selection Reshuffle things a bit and make GSK_DEBUG=renderer print out more information about why renderers were skipped or selected.
2024-04-29 14:01:34 +00:00
if (strstr ((const char *) glGetString (GL_RENDERER), "llvmpipe") != NULL)
{
GSK_DEBUG (RENDERER, "Not using '%s': renderer is llvmpipe", g_type_name (renderer_type));
return FALSE;
}
return TRUE;
gsk: Don't use gpu renderers with llvmpipe Unless the renderer has been explicitly selected via the GSK_RENDERER environment variable, don't use it with llvmpipe. It is important that we allow explicit setting to override this, so we can continue to use ngl in ci, where we don't have hw and want to test with llvmpipe. This should address many of the "performance is terrible in GNOME OS" complaints that are coming from people running in VMs, etc.
2024-02-12 19:16:09 +00:00
}
renderer: Split function per-backend renderers and GL renderers are a different thing, so treat them as such. Also, try the GL renderer unconditionally. The renderer initialization code will take care of GL not being available.
2023-12-21 13:24:11 +00:00
static GType
get_renderer_for_gl (GdkSurface *surface)
{
gsk: Add debug spew to renderer selection Reshuffle things a bit and make GSK_DEBUG=renderer print out more information about why renderers were skipped or selected.
2024-04-29 14:01:34 +00:00
if (!gl_supported_platform (surface, gsk_ngl_renderer_get_type (), FALSE))
gsk: Don't use gpu renderers with llvmpipe Unless the renderer has been explicitly selected via the GSK_RENDERER environment variable, don't use it with llvmpipe. It is important that we allow explicit setting to override this, so we can continue to use ngl in ci, where we don't have hw and want to test with llvmpipe. This should address many of the "performance is terrible in GNOME OS" complaints that are coming from people running in VMs, etc.
2024-02-12 19:16:09 +00:00
return G_TYPE_INVALID;
gsk: Change the default renderer The intent of this change to get wider testing and verify that the new renderers are production-ready. If significant problems show up, we will revert this change for 4.14. The new preference order is ngl > gl > vulkan > cairo. The gl renderer is still there because we need it to support gles2 systems, and vulkan still has some rough edges in application support (no gl area support, webkit only works with gl). If you need to override the default renderer choice, you can still use the GSK_RENDERER environment variable.
2024-01-25 15:09:04 +00:00
return gsk_ngl_renderer_get_type ();
renderer: Split function per-backend renderers and GL renderers are a different thing, so treat them as such. Also, try the GL renderer unconditionally. The renderer initialization code will take care of GL not being available.
2023-12-21 13:24:11 +00:00
}
gsk: Add debug spew to renderer selection Reshuffle things a bit and make GSK_DEBUG=renderer print out more information about why renderers were skipped or selected.
2024-04-29 14:01:34 +00:00
static GType
get_renderer_for_gl_fallback (GdkSurface *surface)
{
if (!gl_supported_platform (surface, GSK_TYPE_GL_RENDERER, TRUE))
return G_TYPE_INVALID;
return GSK_TYPE_GL_RENDERER;
}
gsk: Don't use gpu renderers with llvmpipe Unless the renderer has been explicitly selected via the GSK_RENDERER environment variable, don't use it with llvmpipe. It is important that we allow explicit setting to override this, so we can continue to use ngl in ci, where we don't have hw and want to test with llvmpipe. This should address many of the "performance is terrible in GNOME OS" complaints that are coming from people running in VMs, etc.
2024-02-12 19:16:09 +00:00
#ifdef GDK_RENDERING_VULKAN
static gboolean
gsk: Add debug spew to renderer selection Reshuffle things a bit and make GSK_DEBUG=renderer print out more information about why renderers were skipped or selected.
2024-04-29 14:01:34 +00:00
vulkan_supported_platform (GdkSurface *surface,
GType renderer_type,
gboolean as_fallback)
gsk: Don't use gpu renderers with llvmpipe Unless the renderer has been explicitly selected via the GSK_RENDERER environment variable, don't use it with llvmpipe. It is important that we allow explicit setting to override this, so we can continue to use ngl in ci, where we don't have hw and want to test with llvmpipe. This should address many of the "performance is terrible in GNOME OS" complaints that are coming from people running in VMs, etc.
2024-02-12 19:16:09 +00:00
{
GdkDisplay *display = gdk_surface_get_display (surface);
VkPhysicalDeviceProperties props;
gsk: Add debug spew to renderer selection Reshuffle things a bit and make GSK_DEBUG=renderer print out more information about why renderers were skipped or selected.
2024-04-29 14:01:34 +00:00
GError *error = NULL;
gsk: Don't use gpu renderers with llvmpipe Unless the renderer has been explicitly selected via the GSK_RENDERER environment variable, don't use it with llvmpipe. It is important that we allow explicit setting to override this, so we can continue to use ngl in ci, where we don't have hw and want to test with llvmpipe. This should address many of the "performance is terrible in GNOME OS" complaints that are coming from people running in VMs, etc.
2024-02-12 19:16:09 +00:00
gsk: Add debug spew to renderer selection Reshuffle things a bit and make GSK_DEBUG=renderer print out more information about why renderers were skipped or selected.
2024-04-29 14:01:34 +00:00
if (!gdk_display_init_vulkan (display, &error))
{
if (!as_fallback)
GSK_DEBUG (RENDERER, "Not using Vulkan: %s", error->message);
g_clear_error (&error);
return FALSE;
}
gsk: Don't use gpu renderers with llvmpipe Unless the renderer has been explicitly selected via the GSK_RENDERER environment variable, don't use it with llvmpipe. It is important that we allow explicit setting to override this, so we can continue to use ngl in ci, where we don't have hw and want to test with llvmpipe. This should address many of the "performance is terrible in GNOME OS" complaints that are coming from people running in VMs, etc.
2024-02-12 19:16:09 +00:00
fixup! gsk: Don't use gpu renderers with llvmpipe
2024-02-12 19:41:14 +00:00
vkGetPhysicalDeviceProperties (display->vk_physical_device, &props);
gsk: Don't use gpu renderers with llvmpipe Unless the renderer has been explicitly selected via the GSK_RENDERER environment variable, don't use it with llvmpipe. It is important that we allow explicit setting to override this, so we can continue to use ngl in ci, where we don't have hw and want to test with llvmpipe. This should address many of the "performance is terrible in GNOME OS" complaints that are coming from people running in VMs, etc.
2024-02-12 19:16:09 +00:00
gsk: Add debug spew to renderer selection Reshuffle things a bit and make GSK_DEBUG=renderer print out more information about why renderers were skipped or selected.
2024-04-29 14:01:34 +00:00
if (props.deviceType == VK_PHYSICAL_DEVICE_TYPE_CPU)
{
if (!as_fallback)
gsk: Require dmabuf support for Vulkan Don't use the Vulkan renderer if Vulkan doesn't support any dmabuf formats.
2024-05-02 01:26:54 +00:00
GSK_DEBUG (RENDERER, "Not using '%s': device is CPU", g_type_name (renderer_type));
return FALSE;
}
Make dmabuf initialization lazier Only initialize the Vulkan or EGL parts where possible. When dmabufs or dmabuf formats are actually used, we still initialize fully by creating both a Vulkan and EGL downloader. This shortens the time to first commit from 149ms to 108ms.
2024-09-16 07:54:19 +00:00
#ifdef HAVE_DMABUF
gdk_vulkan_init_dmabuf (display);
gsk: Require dmabuf support for Vulkan Don't use the Vulkan renderer if Vulkan doesn't support any dmabuf formats.
2024-05-02 01:26:54 +00:00
if (!display->vk_dmabuf_formats ||
gdk_dmabuf_formats_get_n_formats (display->vk_dmabuf_formats) == 0)
{
if (!as_fallback)
GSK_DEBUG (RENDERER, "Not using '%s': no dmabuf support", g_type_name (renderer_type));
gsk: Add debug spew to renderer selection Reshuffle things a bit and make GSK_DEBUG=renderer print out more information about why renderers were skipped or selected.
2024-04-29 14:01:34 +00:00
return FALSE;
}
Make dmabuf initialization lazier Only initialize the Vulkan or EGL parts where possible. When dmabufs or dmabuf formats are actually used, we still initialize fully by creating both a Vulkan and EGL downloader. This shortens the time to first commit from 149ms to 108ms.
2024-09-16 07:54:19 +00:00
#endif
gsk: Don't use gpu renderers with llvmpipe Unless the renderer has been explicitly selected via the GSK_RENDERER environment variable, don't use it with llvmpipe. It is important that we allow explicit setting to override this, so we can continue to use ngl in ci, where we don't have hw and want to test with llvmpipe. This should address many of the "performance is terrible in GNOME OS" complaints that are coming from people running in VMs, etc.
2024-02-12 19:16:09 +00:00
gsk: Add debug spew to renderer selection Reshuffle things a bit and make GSK_DEBUG=renderer print out more information about why renderers were skipped or selected.
2024-04-29 14:01:34 +00:00
if (as_fallback)
return TRUE;
renderer: Add Vulkan renderer to the list of renderers It's better than the Cairo renderer, so use it instead. It's still only picked once GL fails, so it will probably only ever be picked when people use GDK_DEBUG=gl-disable, but at least it will be picked.
2023-12-21 13:27:23 +00:00
gsk: Only prefer Vulkan on Wayland Make Vulkan the default on Vulkan-friendly platforms. For now, that list only includes Wayland.
2024-04-20 21:46:07 +00:00
#ifdef GDK_WINDOWING_WAYLAND
if (GDK_IS_WAYLAND_DISPLAY (gdk_surface_get_display (surface)))
return TRUE;
#endif
gsk: Add debug spew to renderer selection Reshuffle things a bit and make GSK_DEBUG=renderer print out more information about why renderers were skipped or selected.
2024-04-29 14:01:34 +00:00
GSK_DEBUG (RENDERER, "Not using '%s': platform is not Wayland", g_type_name (renderer_type));
gsk: Only prefer Vulkan on Wayland Make Vulkan the default on Vulkan-friendly platforms. For now, that list only includes Wayland.
2024-04-20 21:46:07 +00:00
return FALSE;
}
static GType
gsk: Add debug spew to renderer selection Reshuffle things a bit and make GSK_DEBUG=renderer print out more information about why renderers were skipped or selected.
2024-04-29 14:01:34 +00:00
get_renderer_for_vulkan (GdkSurface *surface)
gsk: Only prefer Vulkan on Wayland Make Vulkan the default on Vulkan-friendly platforms. For now, that list only includes Wayland.
2024-04-20 21:46:07 +00:00
{
gsk: Add debug spew to renderer selection Reshuffle things a bit and make GSK_DEBUG=renderer print out more information about why renderers were skipped or selected.
2024-04-29 14:01:34 +00:00
if (!vulkan_supported_platform (surface, GSK_TYPE_VULKAN_RENDERER, FALSE))
return G_TYPE_INVALID;
gsk: Only prefer Vulkan on Wayland Make Vulkan the default on Vulkan-friendly platforms. For now, that list only includes Wayland.
2024-04-20 21:46:07 +00:00
gsk: Add debug spew to renderer selection Reshuffle things a bit and make GSK_DEBUG=renderer print out more information about why renderers were skipped or selected.
2024-04-29 14:01:34 +00:00
return GSK_TYPE_VULKAN_RENDERER;
gsk: Only prefer Vulkan on Wayland Make Vulkan the default on Vulkan-friendly platforms. For now, that list only includes Wayland.
2024-04-20 21:46:07 +00:00
}
gsk: Change the default renderer The intent of this change to get wider testing and verify that the new renderers are production-ready. If significant problems show up, we will revert this change for 4.14. The new preference order is ngl > gl > vulkan > cairo. The gl renderer is still there because we need it to support gles2 systems, and vulkan still has some rough edges in application support (no gl area support, webkit only works with gl). If you need to override the default renderer choice, you can still use the GSK_RENDERER environment variable.
2024-01-25 15:09:04 +00:00
static GType
gsk: Add debug spew to renderer selection Reshuffle things a bit and make GSK_DEBUG=renderer print out more information about why renderers were skipped or selected.
2024-04-29 14:01:34 +00:00
get_renderer_for_vulkan_fallback (GdkSurface *surface)
gsk: Change the default renderer The intent of this change to get wider testing and verify that the new renderers are production-ready. If significant problems show up, we will revert this change for 4.14. The new preference order is ngl > gl > vulkan > cairo. The gl renderer is still there because we need it to support gles2 systems, and vulkan still has some rough edges in application support (no gl area support, webkit only works with gl). If you need to override the default renderer choice, you can still use the GSK_RENDERER environment variable.
2024-01-25 15:09:04 +00:00
{
gsk: Add debug spew to renderer selection Reshuffle things a bit and make GSK_DEBUG=renderer print out more information about why renderers were skipped or selected.
2024-04-29 14:01:34 +00:00
if (!vulkan_supported_platform (surface, GSK_TYPE_VULKAN_RENDERER, TRUE))
return G_TYPE_INVALID;
return GSK_TYPE_VULKAN_RENDERER;
gsk: Change the default renderer The intent of this change to get wider testing and verify that the new renderers are production-ready. If significant problems show up, we will revert this change for 4.14. The new preference order is ngl > gl > vulkan > cairo. The gl renderer is still there because we need it to support gles2 systems, and vulkan still has some rough edges in application support (no gl area support, webkit only works with gl). If you need to override the default renderer choice, you can still use the GSK_RENDERER environment variable.
2024-01-25 15:09:04 +00:00
}
gsk: Add debug spew to renderer selection Reshuffle things a bit and make GSK_DEBUG=renderer print out more information about why renderers were skipped or selected.
2024-04-29 14:01:34 +00:00
#endif
gsk: Change the default renderer The intent of this change to get wider testing and verify that the new renderers are production-ready. If significant problems show up, we will revert this change for 4.14. The new preference order is ngl > gl > vulkan > cairo. The gl renderer is still there because we need it to support gles2 systems, and vulkan still has some rough edges in application support (no gl area support, webkit only works with gl). If you need to override the default renderer choice, you can still use the GSK_RENDERER environment variable.
2024-01-25 15:09:04 +00:00
gsk: Add gsk_renderer_new_for_window() and remove gsk_renderer_get_for_display(). This new function returns a realized renderer. Because of that, GSK can catch failures to realize, destroy the renderer and try another one. Or in short: I can finally use GTK on Weston with the nvidia binary drivers again. Signed-off-by: Emmanuele Bassi <ebassi@gnome.org>
2016-11-29 03:27:21 +00:00
static GType
Continue renaming window to surface This renames a lot of arguments, local variables and functions.
2018-03-21 10:49:14 +00:00
get_renderer_fallback (GdkSurface *surface)
gsk: Add gsk_renderer_new_for_window() and remove gsk_renderer_get_for_display(). This new function returns a realized renderer. Because of that, GSK can catch failures to realize, destroy the renderer and try another one. Or in short: I can finally use GTK on Weston with the nvidia binary drivers again. Signed-off-by: Emmanuele Bassi <ebassi@gnome.org>
2016-11-29 03:27:21 +00:00
{
return GSK_TYPE_CAIRO_RENDERER;
}
static struct {
Continue renaming window to surface This renames a lot of arguments, local variables and functions.
2018-03-21 10:49:14 +00:00
GType (* get_renderer) (GdkSurface *surface);
gsk: Add gsk_renderer_new_for_window() and remove gsk_renderer_get_for_display(). This new function returns a realized renderer. Because of that, GSK can catch failures to realize, destroy the renderer and try another one. Or in short: I can finally use GTK on Weston with the nvidia binary drivers again. Signed-off-by: Emmanuele Bassi <ebassi@gnome.org>
2016-11-29 03:27:21 +00:00
} renderer_possibilities[] = {
gsk: Add debug spew to renderer selection Reshuffle things a bit and make GSK_DEBUG=renderer print out more information about why renderers were skipped or selected.
2024-04-29 14:01:34 +00:00
{ get_renderer_for_display },
{ get_renderer_for_env_var },
{ get_renderer_for_backend },
#ifdef GDK_RENDERING_VULKAN
{ get_renderer_for_vulkan },
#endif
{ get_renderer_for_gl },
#ifdef GDK_RENDERING_VULKAN
{ get_renderer_for_vulkan_fallback },
#endif
{ get_renderer_for_gl_fallback },
{ get_renderer_fallback },
gsk: Add gsk_renderer_new_for_window() and remove gsk_renderer_get_for_display(). This new function returns a realized renderer. Because of that, GSK can catch failures to realize, destroy the renderer and try another one. Or in short: I can finally use GTK on Weston with the nvidia binary drivers again. Signed-off-by: Emmanuele Bassi <ebassi@gnome.org>
2016-11-29 03:27:21 +00:00
};
Initial implementation of GSK rendering pipeline GSK is conceptually split into two scene graphs: * a simple rendering tree of operations * a complex set of logical layers The latter is built on the former, and adds convenience and high level API for application developers. The lower layer, though, is what gets transformed into the rendering pipeline, as it's simple and thus can be transformed into appropriate rendering commands with minimal state changes. The lower layer is also suitable for reuse from more complex higher layers, like the CSS machinery in GTK, without necessarily port those layers to the GSK high level API. This lower layer is based on GskRenderNode instances, which represent the tree of rendering operations; and a GskRenderer instance, which takes the render nodes and submits them (after potentially reordering and transforming them to a more appropriate representation) to the underlying graphic system.
2016-03-17 13:48:19 +00:00
gsk: Add gsk_renderer_new_for_window() and remove gsk_renderer_get_for_display(). This new function returns a realized renderer. Because of that, GSK can catch failures to realize, destroy the renderer and try another one. Or in short: I can finally use GTK on Weston with the nvidia binary drivers again. Signed-off-by: Emmanuele Bassi <ebassi@gnome.org>
2016-11-29 03:27:21 +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
* gsk_renderer_new_for_surface:
gskrenderer: Add property annotations Connect properties, getters, and setters with annotations
2021-02-25 11:59:41 +00:00
* @surface: a `GdkSurface`
gsk: Add gsk_renderer_new_for_window() and remove gsk_renderer_get_for_display(). This new function returns a realized renderer. Because of that, GSK can catch failures to realize, destroy the renderer and try another one. Or in short: I can finally use GTK on Weston with the nvidia binary drivers again. Signed-off-by: Emmanuele Bassi <ebassi@gnome.org>
2016-11-29 03:27:21 +00:00
*
gskrenderer: Add property annotations Connect properties, getters, and setters with annotations
2021-02-25 11:59:41 +00:00
* Creates an appropriate `GskRenderer` instance for the given @surface.
gsk: Add gsk_renderer_new_for_window() and remove gsk_renderer_get_for_display(). This new function returns a realized renderer. Because of that, GSK can catch failures to realize, destroy the renderer and try another one. Or in short: I can finally use GTK on Weston with the nvidia binary drivers again. Signed-off-by: Emmanuele Bassi <ebassi@gnome.org>
2016-11-29 03:27:21 +00:00
*
docs: Add details for gsk_renderer_new_for_surface Mention the GSK_RENDERER variable here.
2020-10-29 18:58:12 +00:00
* If the `GSK_RENDERER` environment variable is set, GSK will
* try that renderer first, before trying the backend-specific
* default. The ultimate fallback is the cairo renderer.
*
* The renderer will be realized before it is returned.
gsk: Add gsk_renderer_new_for_window() and remove gsk_renderer_get_for_display(). This new function returns a realized renderer. Because of that, GSK can catch failures to realize, destroy the renderer and try another one. Or in short: I can finally use GTK on Weston with the nvidia binary drivers again. Signed-off-by: Emmanuele Bassi <ebassi@gnome.org>
2016-11-29 03:27:21 +00:00
*
gskrenderer: Add property annotations Connect properties, getters, and setters with annotations
2021-02-25 11:59:41 +00:00
* Returns: (transfer full) (nullable): a `GskRenderer`
gsk: Add gsk_renderer_new_for_window() and remove gsk_renderer_get_for_display(). This new function returns a realized renderer. Because of that, GSK can catch failures to realize, destroy the renderer and try another one. Or in short: I can finally use GTK on Weston with the nvidia binary drivers again. Signed-off-by: Emmanuele Bassi <ebassi@gnome.org>
2016-11-29 03:27:21 +00:00
*/
GskRenderer *
Continue renaming window to surface This renames a lot of arguments, local variables and functions.
2018-03-21 10:49:14 +00:00
gsk_renderer_new_for_surface (GdkSurface *surface)
gsk: Add gsk_renderer_new_for_window() and remove gsk_renderer_get_for_display(). This new function returns a realized renderer. Because of that, GSK can catch failures to realize, destroy the renderer and try another one. Or in short: I can finally use GTK on Weston with the nvidia binary drivers again. Signed-off-by: Emmanuele Bassi <ebassi@gnome.org>
2016-11-29 03:27:21 +00:00
{
GType renderer_type;
GskRenderer *renderer;
gskrenderer: Add GError argument to gsk_renderer_realize() This way, we don't spam criticals when GL is not available. Instead, we print a useful debug message to stderr and continue with the Cairo renderer. Signed-off-by: Emmanuele Bassi <ebassi@gnome.org>
2016-11-29 03:51:07 +00:00
GError *error = NULL;
gsk: Add gsk_renderer_new_for_window() and remove gsk_renderer_get_for_display(). This new function returns a realized renderer. Because of that, GSK can catch failures to realize, destroy the renderer and try another one. Or in short: I can finally use GTK on Weston with the nvidia binary drivers again. Signed-off-by: Emmanuele Bassi <ebassi@gnome.org>
2016-11-29 03:27:21 +00:00
guint i;
Continue renaming window to surface This renames a lot of arguments, local variables and functions.
2018-03-21 10:49:14 +00:00
g_return_val_if_fail (GDK_IS_SURFACE (surface), NULL);
gsk: Add gsk_renderer_new_for_window() and remove gsk_renderer_get_for_display(). This new function returns a realized renderer. Because of that, GSK can catch failures to realize, destroy the renderer and try another one. Or in short: I can finally use GTK on Weston with the nvidia binary drivers again. Signed-off-by: Emmanuele Bassi <ebassi@gnome.org>
2016-11-29 03:27:21 +00:00
for (i = 0; i < G_N_ELEMENTS (renderer_possibilities); i++)
{
Continue renaming window to surface This renames a lot of arguments, local variables and functions.
2018-03-21 10:49:14 +00:00
renderer_type = renderer_possibilities[i].get_renderer (surface);
gsk: Add gsk_renderer_new_for_window() and remove gsk_renderer_get_for_display(). This new function returns a realized renderer. Because of that, GSK can catch failures to realize, destroy the renderer and try another one. Or in short: I can finally use GTK on Weston with the nvidia binary drivers again. Signed-off-by: Emmanuele Bassi <ebassi@gnome.org>
2016-11-29 03:27:21 +00:00
if (renderer_type == G_TYPE_INVALID)
continue;
renderer: Remove display property Renderers don't need a display until they get realized. And once they get realized, they can look up the display from the surface.
2019-03-09 12:36:14 +00:00
renderer = g_object_new (renderer_type, NULL);
gsk: Add gsk_renderer_new_for_window() and remove gsk_renderer_get_for_display(). This new function returns a realized renderer. Because of that, GSK can catch failures to realize, destroy the renderer and try another one. Or in short: I can finally use GTK on Weston with the nvidia binary drivers again. Signed-off-by: Emmanuele Bassi <ebassi@gnome.org>
2016-11-29 03:27:21 +00:00
Continue renaming window to surface This renames a lot of arguments, local variables and functions.
2018-03-21 10:49:14 +00:00
if (gsk_renderer_realize (renderer, surface, &error))
gsk: Add gsk_renderer_new_for_window() and remove gsk_renderer_get_for_display(). This new function returns a realized renderer. Because of that, GSK can catch failures to realize, destroy the renderer and try another one. Or in short: I can finally use GTK on Weston with the nvidia binary drivers again. Signed-off-by: Emmanuele Bassi <ebassi@gnome.org>
2016-11-29 03:27:21 +00:00
{
gsk: Add debug spew to renderer selection Reshuffle things a bit and make GSK_DEBUG=renderer print out more information about why renderers were skipped or selected.
2024-04-29 14:01:34 +00:00
GSK_DEBUG (RENDERER,
"Using renderer '%s' for surface '%s'",
G_OBJECT_TYPE_NAME (renderer),
G_OBJECT_TYPE_NAME (surface));
gsk: Add gsk_renderer_new_for_window() and remove gsk_renderer_get_for_display(). This new function returns a realized renderer. Because of that, GSK can catch failures to realize, destroy the renderer and try another one. Or in short: I can finally use GTK on Weston with the nvidia binary drivers again. Signed-off-by: Emmanuele Bassi <ebassi@gnome.org>
2016-11-29 03:27:21 +00:00
return renderer;
}
gsk: Add debug spew to renderer selection Reshuffle things a bit and make GSK_DEBUG=renderer print out more information about why renderers were skipped or selected.
2024-04-29 14:01:34 +00:00
GSK_DEBUG (RENDERER,
"Failed to realize renderer '%s' for surface '%s': %s",
gsk: Complain if we fail to realize a renderer The only likely place where this is going to happen is if a renderer was explicitly requested with the GSK_RENDERER environment variable, and in that case, it is misleading to silently use a different renderer.
2020-09-07 15:17:24 +00:00
G_OBJECT_TYPE_NAME (renderer),
G_OBJECT_TYPE_NAME (surface),
error->message);
gsk: Add debug spew to renderer selection Reshuffle things a bit and make GSK_DEBUG=renderer print out more information about why renderers were skipped or selected.
2024-04-29 14:01:34 +00:00
gsk: Add gsk_renderer_new_for_window() and remove gsk_renderer_get_for_display(). This new function returns a realized renderer. Because of that, GSK can catch failures to realize, destroy the renderer and try another one. Or in short: I can finally use GTK on Weston with the nvidia binary drivers again. Signed-off-by: Emmanuele Bassi <ebassi@gnome.org>
2016-11-29 03:27:21 +00:00
g_object_unref (renderer);
gskrenderer: Add GError argument to gsk_renderer_realize() This way, we don't spam criticals when GL is not available. Instead, we print a useful debug message to stderr and continue with the Cairo renderer. Signed-off-by: Emmanuele Bassi <ebassi@gnome.org>
2016-11-29 03:51:07 +00:00
g_clear_error (&error);
gsk: Add gsk_renderer_new_for_window() and remove gsk_renderer_get_for_display(). This new function returns a realized renderer. Because of that, GSK can catch failures to realize, destroy the renderer and try another one. Or in short: I can finally use GTK on Weston with the nvidia binary drivers again. Signed-off-by: Emmanuele Bassi <ebassi@gnome.org>
2016-11-29 03:27:21 +00:00
}
Initial implementation of GSK rendering pipeline GSK is conceptually split into two scene graphs: * a simple rendering tree of operations * a complex set of logical layers The latter is built on the former, and adds convenience and high level API for application developers. The lower layer, though, is what gets transformed into the rendering pipeline, as it's simple and thus can be transformed into appropriate rendering commands with minimal state changes. The lower layer is also suitable for reuse from more complex higher layers, like the CSS machinery in GTK, without necessarily port those layers to the GSK high level API. This lower layer is based on GskRenderNode instances, which represent the tree of rendering operations; and a GskRenderer instance, which takes the render nodes and submits them (after potentially reordering and transforming them to a more appropriate representation) to the underlying graphic system.
2016-03-17 13:48:19 +00:00
gsk: Add gsk_renderer_new_for_window() and remove gsk_renderer_get_for_display(). This new function returns a realized renderer. Because of that, GSK can catch failures to realize, destroy the renderer and try another one. Or in short: I can finally use GTK on Weston with the nvidia binary drivers again. Signed-off-by: Emmanuele Bassi <ebassi@gnome.org>
2016-11-29 03:27:21 +00:00
g_assert_not_reached ();
return NULL;
Initial implementation of GSK rendering pipeline GSK is conceptually split into two scene graphs: * a simple rendering tree of operations * a complex set of logical layers The latter is built on the former, and adds convenience and high level API for application developers. The lower layer, though, is what gets transformed into the rendering pipeline, as it's simple and thus can be transformed into appropriate rendering commands with minimal state changes. The lower layer is also suitable for reuse from more complex higher layers, like the CSS machinery in GTK, without necessarily port those layers to the GSK high level API. This lower layer is based on GskRenderNode instances, which represent the tree of rendering operations; and a GskRenderer instance, which takes the render nodes and submits them (after potentially reordering and transforming them to a more appropriate representation) to the underlying graphic system.
2016-03-17 13:48:19 +00:00
}
gsk: Add the ability to create fallback renderers While porting GTK to GskRenderer we noticed that the current fallback code for widgets using Cairo to draw is not enough to cover all the possible cases. For instance, if a container widget still uses GtkWidget::draw to render its children, and at least one of them has been ported to using render nodes instead, the container won't know how to draw it. For this reason we want to provide to layers above GSK the ability to create a "fallback" renderer instance, created using a "parent" GskRenderer instance, but using a Cairo context as the rendering target instead of a GdkDrawingContext. GTK will use this inside the gtk_widget_draw() implementation, if a widget implements GtkWidgetClass.get_render_node().
2016-08-25 10:31:56 +00:00
gsk: make logging per-renderer Add a setter for per-renderer debug flags, and use them where possible. Some places don't have easy access to a renderer, so this is not complete. Also, use g_message instead of g_print throughout.
2018-01-14 14:52:52 +00:00
GskDebugFlags
gsk_renderer_get_debug_flags (GskRenderer *renderer)
{
GskRendererPrivate *priv = gsk_renderer_get_instance_private (renderer);
g_return_val_if_fail (GSK_IS_RENDERER (renderer), 0);
return priv->debug_flags;
}
void
gsk_renderer_set_debug_flags (GskRenderer *renderer,
GskDebugFlags flags)
{
GskRendererPrivate *priv = gsk_renderer_get_instance_private (renderer);
g_return_if_fail (GSK_IS_RENDERER (renderer));
priv->debug_flags = flags;
}
gsk: Add a helper for converting textures This is a simple helper that feed a GdkTexture through a renderer and returns the resulting texture. This will be used to convert dmabuf textures to 'native' textures.
2023-10-22 13:39:47 +00:00
Reference in New Issue Copy Permalink