AuroraMiddleware/gtk
1
0
Fork 1
mirror of https://gitlab.gnome.org/GNOME/gtk.git synced 2024-11-14 04:31:09 +00:00
Code Issues Projects Releases Wiki Activity
86e907b088
gtk/gsk/gl/gskglrenderer.c

3505 lines
120 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
#include "config.h"
gsk: Export gsk_gl_renderer_new()
2019-05-02 00:13:16 +00:00
#include "gskglrenderer.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"
#include "gskenums.h"
gsk: Add GskGLDriver We can move the caching and management of textures, VAOs, and state of the GL machinery into a single object, GskGLDriver.
2016-07-08 15:21:13 +00:00
#include "gskgldriverprivate.h"
gsk: Add GL profiler We can use the GL_ARB_timer_query extension (available since OpenGL 3.2, and part of the OpenGL specification since version 3.3) to query the time elapsed when drawing each frame. This allows us to gather timing information on our use of the GPU.
2016-07-12 13:50:48 +00:00
#include "gskglprofilerprivate.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 "gskrendererprivate.h"
rendernode: Make the transform node take a GskTransform This is an attempt to push GskTransform deeper into the stack.
2019-03-01 05:35:55 +00:00
#include "gsktransformprivate.h"
gsk: Rework how GLSL shaders are built The GL renderer should build the GLSL shaders using GskShaderBuilder. This allows us to separate the common parts into separate files, and assemble them as necessary, instead of shipping one big shader per type of GL API (GL3, GL legacy, and GLES).
2016-07-03 20:12:22 +00:00
#include "gskshaderbuilderprivate.h"
gl: Add glyph cache Based on the one used by the vulkan renderer
2017-11-18 13:30:57 +00:00
#include "gskglglyphcacheprivate.h"
gl renderer: Add & use icon cache Upload small icons all to the same texture atlas.
2019-05-22 07:33:25 +00:00
#include "gskgliconcacheprivate.h"
gl renderer: Move render ops into separate file
2017-11-22 20:02:50 +00:00
#include "gskglrenderopsprivate.h"
gl renderer: draw all outset shadows Instead of falling back to cairo for most of them.
2017-12-28 15:41:32 +00:00
#include "gskcairoblurprivate.h"
gl renderer: Cache blurred outset shadow nodes Since these are particularly expensive to render and we have a pretty big one used in every client-side decorated window.
2018-07-08 18:08:15 +00:00
#include "gskglshadowcacheprivate.h"
gl renderer: Add NodeSample As a quick way of checking what a particular sample of nodes (e.g. all offset node children) are made up of.
2018-12-02 09:20:59 +00:00
#include "gskglnodesampleprivate.h"
rendernode: Make the transform node take a GskTransform This is an attempt to push GskTransform deeper into the stack.
2019-03-01 05:35:55 +00:00
#include "gsktransform.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 "gskprivate.h"
gdk: Split out GL texture Put GdkGLTexture into its own file and rename the API to gdk_gl_texture_foo() instead of gdk_texture_foo_for_gl(). Apart from naming, no actual code changes.
2018-03-05 13:38:38 +00:00
#include "gdk/gdkgltextureprivate.h"
GskGLRenderer: Label various gl objects This means the names are more useful in tools like renderdoc.
2019-04-24 11:27:43 +00:00
#include "gdk/gdkglcontextprivate.h"
gsk: Add tracing to the gl renderer Emit the equivalent of the cpu-time counter in the inspector.
2018-05-19 19:25:17 +00:00
#include "gdk/gdkprofilerprivate.h"
gdk: Split out GL texture Put GdkGLTexture into its own file and rename the API to gdk_gl_texture_foo() instead of gdk_texture_foo_for_gl(). Apart from naming, no actual code changes.
2018-03-05 13:38:38 +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 <epoxy/gl.h>
gl: Add glyph cache Based on the one used by the vulkan renderer
2017-11-18 13:30:57 +00:00
#include <cairo-ft.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
gsk: Use the appropriate GLSL version The GLSL versions are: OpenGL 2.1: #version 110 OpenGL 3.0: #version 130 OpenGL 3.2: #version 150 OpenGLES 2.0: #version 100 OpenGLES 3.0: #version 300 es So we need to check the version of the GdkGLContext if we want use the appropriate version, especially for legacy OpenGL contexts, which can be both 3.x and 2.x.
2016-11-01 15:00:31 +00:00
#define SHADER_VERSION_GLES 100
#define SHADER_VERSION_GL2_LEGACY 110
#define SHADER_VERSION_GL3_LEGACY 130
gsk: Don't store the uniform and attribute location twice We should keep the ShaderBuilder around and use it to query the various uniform and attribute locations when needed, instead of storing those offsets into the Renderer instance, and copying them. This allows a bit more flexibility, once we have more than one program built into the renderer.
2016-07-03 21:54:30 +00:00
#define SHADER_VERSION_GL3 150
Rework the GL renderer
2017-11-03 12:09:02 +00:00
#define ORTHO_NEAR_PLANE -10000
#define ORTHO_FAR_PLANE 10000
#define HIGHLIGHT_FALLBACK 0
gl renderer: Rework once more Last time, I swear.
2017-11-22 10:32:23 +00:00
#define DEBUG_OPS 0
gl renderer: try doing outset box shadows Still fall back in cases we can't handle that way.
2017-12-21 17:09:32 +00:00
#define SHADOW_EXTRA_SIZE 4
gl renderer: Rework once more Last time, I swear.
2017-11-22 10:32:23 +00:00
#if DEBUG_OPS
#define OP_PRINT(format, ...) g_print(format, ## __VA_ARGS__)
#else
#define OP_PRINT(format, ...)
#endif
gl renderer: Rename a macro
2017-12-01 12:56:56 +00:00
#define INIT_PROGRAM_UNIFORM_LOCATION(program_name, uniform_basename) \
gl renderer: Rework once more Last time, I swear.
2017-11-22 10:32:23 +00:00
G_STMT_START{\
gl renderer: Rework program creation Make sure all uniform names have to match between the shader names and the _location integers we save in every Program struct.
2017-11-30 17:47:55 +00:00
self->program_name ## _program.program_name.uniform_basename ## _location = \
glGetUniformLocation(self->program_name ## _program.id, "u_" #uniform_basename);\
g_assert_cmpint (self->program_name ## _program.program_name.uniform_basename ## _location, >, -1); \
gl renderer: Rework once more Last time, I swear.
2017-11-22 10:32:23 +00:00
}G_STMT_END
gl renderer: Rework program creation Make sure all uniform names have to match between the shader names and the _location integers we save in every Program struct.
2017-11-30 17:47:55 +00:00
#define INIT_COMMON_UNIFORM_LOCATION(program_ptr, uniform_basename) \
G_STMT_START{\
program_ptr->uniform_basename ## _location = \
glGetUniformLocation(program_ptr->id, "u_" #uniform_basename);\
}G_STMT_END
gl renderer: Support (not) resetting the opacity for offscreen nodes We usually want to do that, but it's wrong for e.g. crossfade nodes.
2019-01-18 12:06:41 +00:00
typedef enum
{
gl renderer: Add debug code to dump framebuffer This way we can specify it on specific add_offscreen_ops callsites.
2019-03-31 04:14:41 +00:00
FORCE_OFFSCREEN = 1 << 0,
RESET_CLIP = 1 << 1,
RESET_OPACITY = 1 << 2,
DUMP_FRAMEBUFFER = 1 << 3
gl renderer: Support (not) resetting the opacity for offscreen nodes We usually want to do that, but it's wrong for e.g. crossfade nodes.
2019-01-18 12:06:41 +00:00
} OffscreenFlags;
Consider all offscreen drawings for the icon cache
2019-06-04 17:28:59 +00:00
typedef struct
{
int texture_id;
float x;
float y;
float x2;
float y2;
} TextureRegion;
static inline void
init_full_texture_region (TextureRegion *r,
int texture_id)
{
r->texture_id = texture_id;
r->x = 0;
r->y = 0;
r->x2 = 1;
r->y2 = 1;
}
gl renderer: Add helper for printing a render node tree
2018-05-12 04:57:59 +00:00
static void G_GNUC_UNUSED
print_render_node_tree (GskRenderNode *root, int level)
{
#define INDENT 4
const guint type = gsk_render_node_get_node_type (root);
guint i;
switch (type)
{
case GSK_CONTAINER_NODE:
g_print ("%*s Container\n", level * INDENT, " ");
for (i = 0; i < gsk_container_node_get_n_children (root); i++)
print_render_node_tree (gsk_container_node_get_child (root, i), level + 1);
break;
case GSK_TRANSFORM_NODE:
g_print ("%*s Transform\n", level * INDENT, " ");
print_render_node_tree (gsk_transform_node_get_child (root), level + 1);
break;
case GSK_COLOR_MATRIX_NODE:
g_print ("%*s Color Matrix\n", level * INDENT, " ");
print_render_node_tree (gsk_color_matrix_node_get_child (root), level + 1);
break;
case GSK_CROSS_FADE_NODE:
g_print ("%*s Crossfade(%.2f)\n", level * INDENT, " ",
gsk_cross_fade_node_get_progress (root));
print_render_node_tree (gsk_cross_fade_node_get_start_child (root), level + 1);
print_render_node_tree (gsk_cross_fade_node_get_end_child (root), level + 1);
break;
case GSK_TEXT_NODE:
g_print ("%*s Text\n", level * INDENT, " ");
break;
case GSK_SHADOW_NODE:
g_print ("%*s Shadow\n", level * INDENT, " ");
print_render_node_tree (gsk_shadow_node_get_child (root), level + 1);
break;
case GSK_TEXTURE_NODE:
g_print ("%*s Texture %p\n", level * INDENT, " ", gsk_texture_node_get_texture (root));
break;
gl renderer: Add more node types to print_render_node_tree debugging ++
2018-12-02 12:39:55 +00:00
case GSK_DEBUG_NODE:
g_print ("%*s Debug: %s\n", level * INDENT, " ", gsk_debug_node_get_message (root));
print_render_node_tree (gsk_debug_node_get_child (root), level + 1);
break;
case GSK_CLIP_NODE:
g_print ("%*s Clip (%f, %f, %f, %f):\n", level * INDENT, " ",
root->bounds.origin.x, root->bounds.origin.y, root->bounds.size.width, root->bounds.size.height);
print_render_node_tree (gsk_clip_node_get_child (root), level + 1);
break;
gl renderer: Add helper for printing a render node tree
2018-05-12 04:57:59 +00:00
default:
gl renderer: Add more node types to print_render_node_tree debugging ++
2018-12-02 12:39:55 +00:00
g_print ("%*s %s\n", level * INDENT, " ", root->node_class->type_name);
gl renderer: Add helper for printing a render node tree
2018-05-12 04:57:59 +00:00
}
#undef INDENT
}
Rework the GL renderer
2017-11-03 12:09:02 +00:00
static void G_GNUC_UNUSED
dump_framebuffer (const char *filename, int w, int h)
{
int stride = cairo_format_stride_for_width (CAIRO_FORMAT_ARGB32, w);
guchar *data = g_malloc (h * stride);
cairo_surface_t *s;
glReadPixels (0, 0, w, h, GL_BGRA, GL_UNSIGNED_BYTE, data);
gl renderer: Move render ops into separate file
2017-11-22 20:02:50 +00:00
s = cairo_image_surface_create_for_data (data, CAIRO_FORMAT_ARGB32, w, h, stride);
Rework the GL renderer
2017-11-03 12:09:02 +00:00
cairo_surface_write_to_png (s, filename);
cairo_surface_destroy (s);
g_free (data);
}
gl renderer: Add debug function to dump render node
2019-02-24 08:09:02 +00:00
static void G_GNUC_UNUSED
dump_node (GskRenderNode *node,
const char *filename)
{
const int surface_width = ceilf (node->bounds.size.width);
const int surface_height = ceilf (node->bounds.size.height);
cairo_surface_t *surface;
cairo_t *cr;
surface = cairo_image_surface_create (CAIRO_FORMAT_ARGB32,
surface_width,
surface_height);
cr = cairo_create (surface);
cairo_save (cr);
cairo_translate (cr, -node->bounds.origin.x, -node->bounds.origin.y);
gsk_render_node_draw (node, cr);
cairo_restore (cr);
cairo_destroy (cr);
cairo_surface_write_to_png (surface, filename);
cairo_surface_destroy (surface);
}
gl renderer: Rename a macro
2017-12-01 12:56:56 +00:00
static gboolean
gl: Add glyph cache Based on the one used by the vulkan renderer
2017-11-18 13:30:57 +00:00
font_has_color_glyphs (const PangoFont *font)
{
cairo_scaled_font_t *scaled_font;
gboolean has_color = FALSE;
scaled_font = pango_cairo_font_get_scaled_font ((PangoCairoFont *)font);
if (cairo_scaled_font_get_type (scaled_font) == CAIRO_FONT_TYPE_FT)
{
FT_Face ft_face = cairo_ft_scaled_font_lock_face (scaled_font);
has_color = (FT_HAS_COLOR (ft_face) != 0);
cairo_ft_scaled_font_unlock_face (scaled_font);
}
return has_color;
}
Rework the GL renderer
2017-11-03 12:09:02 +00:00
gl renderer: Implement unblurred inset shadows
2017-11-30 15:48:03 +00:00
static inline void
rgba_to_float (const GdkRGBA *c,
float *f)
{
f[0] = c->red;
f[1] = c->green;
f[2] = c->blue;
f[3] = c->alpha;
}
gl renderer: Sort border sides by color
2017-12-05 12:46:29 +00:00
static inline void
sort_border_sides (const GdkRGBA *colors,
int *indices)
{
gboolean done[4] = {0, 0, 0, 0};
int i, k;
int cur = 0;
for (i = 0; i < 3; i ++)
{
if (done[i])
continue;
indices[cur] = i;
done[i] = TRUE;
cur ++;
for (k = i + 1; k < 4; k ++)
{
if (gdk_rgba_equal (&colors[k], &colors[i]))
{
indices[cur] = k;
done[k] = TRUE;
cur ++;
}
}
if (cur >= 4)
break;
}
}
gl renderer: Add a helper function We'll use this for the common case of a color matrix node inside a shadow node.
2017-12-06 15:07:18 +00:00
static inline gboolean
color_matrix_modifies_alpha (GskRenderNode *node)
{
const graphene_matrix_t *matrix = gsk_color_matrix_node_peek_color_matrix (node);
const graphene_vec4_t *offset = gsk_color_matrix_node_peek_color_offset (node);
graphene_vec4_t row3;
if (graphene_vec4_get_w (offset) != 0.0f)
return TRUE;
graphene_matrix_get_row (matrix, 3, &row3);
gl renderer: use w axis vector from graphene Instead of initializing our own one every time.
2018-05-27 16:05:00 +00:00
return !graphene_vec4_equal (graphene_vec4_w_axis (), &row3);
gl renderer: Add a helper function We'll use this for the common case of a color matrix node inside a shadow node.
2017-12-06 15:07:18 +00:00
}
gl renderer: try doing outset box shadows Still fall back in cases we can't handle that way.
2017-12-21 17:09:32 +00:00
static inline void
gsk_rounded_rect_shrink_to_minimum (GskRoundedRect *self)
{
self->bounds.size.width = ceilf (MAX (MAX (self->corner[0].width, self->corner[1].width),
MAX (self->corner[2].width, self->corner[3].width)) * 2);
self->bounds.size.height = ceilf (MAX (MAX (self->corner[0].height, self->corner[1].height),
MAX (self->corner[2].height, self->corner[3].height)) * 2);
}
gl renderer: Render non-trivial transforms to a texture This way we can e.g. render rotated clips, borders, etc.
2018-11-29 07:09:02 +00:00
static inline gboolean
node_supports_transform (GskRenderNode *node)
{
/* Some nodes can't handle non-trivial transforms without being
* rendered to a texture (e.g. rotated clips, etc.). Some however
* work just fine, mostly because they already draw their child
* to a texture and just render the texture manipulated in some
* way, think opacity or color matrix. */
const guint node_type = gsk_render_node_get_node_type (node);
switch (node_type)
{
case GSK_COLOR_NODE:
case GSK_OPACITY_NODE:
case GSK_COLOR_MATRIX_NODE:
case GSK_TEXTURE_NODE:
gl renderer: Stop determining the matrix category ourselves Use the category we get from transform nodes and add ops_ API to supply one when we set a graphene_matrix_t directly.
2019-02-23 06:50:51 +00:00
case GSK_TRANSFORM_NODE:
case GSK_CROSS_FADE_NODE:
gl renderer: Add more nodes that support transforms
2019-02-26 06:17:08 +00:00
case GSK_LINEAR_GRADIENT_NODE:
case GSK_DEBUG_NODE:
case GSK_TEXT_NODE:
gl renderer: Render non-trivial transforms to a texture This way we can e.g. render rotated clips, borders, etc.
2018-11-29 07:09:02 +00:00
return TRUE;
default:
return FALSE;
}
return FALSE;
}
gl renderer: Factor out a helper function for offscreen drawing
2017-11-24 09:18:51 +00:00
static void gsk_gl_renderer_setup_render_mode (GskGLRenderer *self);
gl renderer: Don't draw texture nodes to a framebuffer We don't need to create a texture from a texture node. We can simply use its texture instead and draw it however we want.
2017-11-24 09:43:17 +00:00
static void add_offscreen_ops (GskGLRenderer *self,
gl renderer: Refactor add_offscreen_ops Use a graphene_rect_t for the node bounds instead of 4 floats. This makes it simpler to pass the size in without the offset applied.
2018-12-02 08:05:50 +00:00
RenderOpBuilder *builder,
const graphene_rect_t *bounds,
GskRenderNode *child_node,
Consider all offscreen drawings for the icon cache
2019-06-04 17:28:59 +00:00
TextureRegion *region_out,
gl renderer: Refactor add_offscreen_ops Use a graphene_rect_t for the node bounds instead of 4 floats. This makes it simpler to pass the size in without the offset applied.
2018-12-02 08:05:50 +00:00
gboolean *is_offscreen,
gl renderer: Support (not) resetting the opacity for offscreen nodes We usually want to do that, but it's wrong for e.g. crossfade nodes.
2019-01-18 12:06:41 +00:00
guint flags);
gl renderer: Use one function per node-type So a profiler can actually tell me what's slow and not just point at _add_render_ops in all cases.
2017-12-08 12:12:43 +00:00
static void gsk_gl_renderer_add_render_ops (GskGLRenderer *self,
GskRenderNode *node,
RenderOpBuilder *builder);
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
struct _GskGLRenderer
{
GskRenderer parent_instance;
Rework the GL renderer
2017-11-03 12:09:02 +00:00
int scale_factor;
gsk: Bind GL context to the GL profiler Similarly to how we bind it to the GL driver object used by the GSK GL renderer.
2016-07-27 10:34:20 +00:00
GdkGLContext *gl_context;
gsk: Add GskGLDriver We can move the caching and management of textures, VAOs, and state of the GL machinery into a single object, GskGLDriver.
2016-07-08 15:21:13 +00:00
GskGLDriver *gl_driver;
gsk: Add GL profiler We can use the GL_ARB_timer_query extension (available since OpenGL 3.2, and part of the OpenGL specification since version 3.3) to query the time elapsed when drawing each frame. This allows us to gather timing information on our use of the GPU.
2016-07-12 13:50:48 +00:00
GskGLProfiler *gl_profiler;
gsk: Consolidate program creation and storage We should use ShaderBuilder to create and store programs for the GL renderer. This allows us to simplify the creation of programs (by moving the compilation phase into the ShaderBuilder::create_program() method), and move towards the ability to create multiple programs and just keep a reference to the program id.
2016-07-04 12:46:22 +00:00
gl renderer: Rework once more Last time, I swear.
2017-11-22 10:32:23 +00:00
union {
gl renderer: Move render ops into separate file
2017-11-22 20:02:50 +00:00
Program programs[GL_N_PROGRAMS];
gl renderer: Rework once more Last time, I swear.
2017-11-22 10:32:23 +00:00
struct {
Program blit_program;
Program color_program;
Program coloring_program;
Program color_matrix_program;
Program linear_gradient_program;
gl renderer: Implement blur nodes
2017-11-25 07:56:50 +00:00
Program blur_program;
gl renderer: Implement unblurred inset shadows
2017-11-30 15:48:03 +00:00
Program inset_shadow_program;
gl renderer: Implement unblurred outset shadows
2017-12-01 07:30:11 +00:00
Program outset_shadow_program;
gl renderer: Render unblurred outset shadows differently We don't need to draw anything to a texure for those.
2018-01-15 09:55:40 +00:00
Program unblurred_outset_shadow_program;
gl renderer: Implement simple border nodes
2017-12-01 10:55:10 +00:00
Program border_program;
gl renderer: Implement cross fade nodes
2017-12-11 07:22:28 +00:00
Program cross_fade_program;
gl renderer: Add simple blend node implementation
2019-04-28 05:46:17 +00:00
Program blend_program;
gl renderer: Rework once more Last time, I swear.
2017-11-22 10:32:23 +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
gl renderer: Keep op builder around GL keeps the unoform state per-program, but not per-frame. So, we can't pretend that this works for us. Keep the RenderOpBuilder around for the entire lifetime of the renderer instead.
2019-04-24 15:55:14 +00:00
RenderOpBuilder op_builder;
gl renderer: Rework once more Last time, I swear.
2017-11-22 10:32:23 +00:00
GArray *render_ops;
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
Share glyph and icon caches Use the same texture atlases to back both the glyph and icon caches, and unify their sizes and management. Store big glyphs in separate textures, so all atlases have the same size. Tweak some of the eviction parameters. We share the caches across all GL contexts on a display, unless the GSK_NO_SHARED_CACHES env var is set.
2019-06-04 21:27:09 +00:00
GskGLTextureAtlases *atlases;
GskGLGlyphCache *glyph_cache;
GskGLIconCache *icon_cache;
gl renderer: Cache blurred outset shadow nodes Since these are particularly expensive to render and we have a pretty big one used in every client-side decorated window.
2018-07-08 18:08:15 +00:00
GskGLShadowCache shadow_cache;
gl: Add glyph cache Based on the one used by the vulkan renderer
2017-11-18 13:30:57 +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
#ifdef G_ENABLE_DEBUG
gl renderer: Define debug structs inline
2017-12-03 15:54:34 +00:00
struct {
GQuark frames;
GQuark draw_calls;
} profile_counters;
struct {
GQuark cpu_time;
GQuark gpu_time;
} profile_timers;
gsk: Add GskProfiler to GskRenderer The profiler instance is per-renderer, and is accesible to implementations.
2016-08-03 15:51:21 +00:00
#endif
gsk: move begin/end_frame vfuncs into the renderers
2018-03-28 13:01:34 +00:00
cairo_region_t *render_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
};
struct _GskGLRendererClass
{
GskRendererClass parent_class;
};
G_DEFINE_TYPE (GskGLRenderer, gsk_gl_renderer, GSK_TYPE_RENDERER)
gl renderer: Add function to draw debug rectangle
2018-12-02 13:31:57 +00:00
static void G_GNUC_UNUSED
add_rect_ops (RenderOpBuilder *builder,
const graphene_rect_t *r)
{
const float min_x = r->origin.x;
const float min_y = r->origin.y;
const float max_x = min_x + r->size.width;
const float max_y = min_y + r->size.height;
ops_draw (builder, (GskQuadVertex[GL_N_VERTICES]) {
{ { min_x, min_y }, { 0, 1 }, },
{ { min_x, max_y }, { 0, 0 }, },
{ { max_x, min_y }, { 1, 1 }, },
{ { max_x, max_y }, { 1, 0 }, },
{ { min_x, max_y }, { 0, 0 }, },
{ { max_x, min_y }, { 1, 1 }, },
});
}
static void G_GNUC_UNUSED
add_rect_outline_ops (GskGLRenderer *self,
RenderOpBuilder *builder,
const graphene_rect_t *rect)
{
ops_set_program (builder, &self->color_program);
ops_set_color (builder, &(GdkRGBA) { 1, 0, 0, 1 });
add_rect_ops (builder,
&GRAPHENE_RECT_INIT (rect->origin.x, rect->origin.y,
1, rect->size.height));
add_rect_ops (builder,
&GRAPHENE_RECT_INIT (rect->origin.x, rect->origin.y,
rect->size.width, 1));
add_rect_ops (builder,
&GRAPHENE_RECT_INIT (rect->origin.x + rect->size.width - 1, rect->origin.y,
1, rect->size.height));
add_rect_ops (builder,
&GRAPHENE_RECT_INIT (rect->origin.x, rect->origin.y + rect->size.height - 1,
rect->size.width, 1));
}
gl renderer: Fix inset and outset shadows in hidpi
2017-12-09 08:41:52 +00:00
static inline void
rounded_rect_to_floats (GskGLRenderer *self,
RenderOpBuilder *builder,
const GskRoundedRect *rect,
float *outline,
float *corner_widths,
float *corner_heights)
{
gl renderer: Render everyhing according to MV scale And not the surface's scale factor. This way the magnifier works.
2018-04-11 09:20:50 +00:00
const float scale = ops_get_scale (builder);
gl renderer: Fix inset and outset shadows in hidpi
2017-12-09 08:41:52 +00:00
int i;
graphene_rect_t transformed_bounds;
gl renderer: Use ops_transform_bounds_modelview in more places
2018-12-02 10:04:15 +00:00
ops_transform_bounds_modelview (builder, &rect->bounds, &transformed_bounds);
gl renderer: Fix inset and outset shadows in hidpi
2017-12-09 08:41:52 +00:00
outline[0] = transformed_bounds.origin.x;
outline[1] = transformed_bounds.origin.y;
outline[2] = transformed_bounds.size.width;
outline[3] = transformed_bounds.size.height;
for (i = 0; i < 4; i ++)
{
gl renderer: Render everyhing according to MV scale And not the surface's scale factor. This way the magnifier works.
2018-04-11 09:20:50 +00:00
corner_widths[i] = rect->corner[i].width * scale;
corner_heights[i] = rect->corner[i].height * scale;
gl renderer: Fix inset and outset shadows in hidpi
2017-12-09 08:41:52 +00:00
}
}
gl renderer: Split out a utility function
2017-12-01 08:58:58 +00:00
static inline void
render_fallback_node (GskGLRenderer *self,
GskRenderNode *node,
gl renderer: Render fallback nodes upside down We stuff both gl-drawn and cairo-drawn textures into the same cache, so we can't really assume that we need to draw any of them flipped or not. Fix this by drawing fallback stuff upside down and then using upside-down vertex data for everything. Fixes #1897
2019-05-18 11:45:19 +00:00
RenderOpBuilder *builder)
gl renderer: Split out a utility function
2017-12-01 08:58:58 +00:00
{
gl renderer: Render fallback nodes upside down We stuff both gl-drawn and cairo-drawn textures into the same cache, so we can't really assume that we need to draw any of them flipped or not. Fix this by drawing fallback stuff upside down and then using upside-down vertex data for everything. Fixes #1897
2019-05-18 11:45:19 +00:00
const float min_x = builder->dx + node->bounds.origin.x;
const float min_y = builder->dy + node->bounds.origin.y;
const float max_x = min_x + node->bounds.size.width;
const float max_y = min_y + node->bounds.size.height;
gl renderer: Fix fallback node scaling
2018-04-15 16:20:52 +00:00
const float scale = ops_get_scale (builder);
gl renderer: Ignore 0-sized fallback nodes
2018-06-26 19:40:59 +00:00
const int surface_width = ceilf (node->bounds.size.width) * scale;
const int surface_height = ceilf (node->bounds.size.height) * scale;
gl renderer: Split out a utility function
2017-12-01 08:58:58 +00:00
cairo_surface_t *surface;
gl renderer: Render recording surface untransformed Cairo can't handle the y flip apparently. Fixes #1906
2019-05-21 06:38:11 +00:00
cairo_surface_t *rendered_surface;
gl renderer: Split out a utility function
2017-12-01 08:58:58 +00:00
cairo_t *cr;
gl renderer: Cache rendered fallback nodes
2019-03-05 08:03:11 +00:00
int cached_id;
gl renderer: Split out a utility function
2017-12-01 08:58:58 +00:00
int texture_id;
gl renderer: Render fallback nodes upside down We stuff both gl-drawn and cairo-drawn textures into the same cache, so we can't really assume that we need to draw any of them flipped or not. Fix this by drawing fallback stuff upside down and then using upside-down vertex data for everything. Fixes #1897
2019-05-18 11:45:19 +00:00
const GskQuadVertex offscreen_vertex_data[GL_N_VERTICES] = {
{ { min_x, min_y }, { 0, 1 }, },
{ { min_x, max_y }, { 0, 0 }, },
{ { max_x, min_y }, { 1, 1 }, },
{ { max_x, max_y }, { 1, 0 }, },
{ { min_x, max_y }, { 0, 0 }, },
{ { max_x, min_y }, { 1, 1 }, },
};
gl renderer: Split out a utility function
2017-12-01 08:58:58 +00:00
gl renderer: Ignore 0-sized fallback nodes
2018-06-26 19:40:59 +00:00
if (surface_width <= 0 ||
surface_height <= 0)
return;
gl renderer: Cache rendered fallback nodes
2019-03-05 08:03:11 +00:00
cached_id = gsk_gl_driver_get_texture_for_pointer (self->gl_driver, node);
if (cached_id != 0)
{
ops_set_program (builder, &self->blit_program);
ops_set_texture (builder, cached_id);
gl renderer: Render fallback nodes upside down We stuff both gl-drawn and cairo-drawn textures into the same cache, so we can't really assume that we need to draw any of them flipped or not. Fix this by drawing fallback stuff upside down and then using upside-down vertex data for everything. Fixes #1897
2019-05-18 11:45:19 +00:00
ops_draw (builder, offscreen_vertex_data);
gl renderer: Cache rendered fallback nodes
2019-03-05 08:03:11 +00:00
return;
}
gl renderer: Render recording surface untransformed Cairo can't handle the y flip apparently. Fixes #1906
2019-05-21 06:38:11 +00:00
/* We first draw the recording surface on an image surface,
* just because the scaleY(-1) later otherwise screws up the
* rendering... */
{
rendered_surface = cairo_image_surface_create (CAIRO_FORMAT_ARGB32,
surface_width,
surface_height);
cairo_surface_set_device_scale (rendered_surface, scale, scale);
cr = cairo_create (rendered_surface);
cairo_save (cr);
cairo_translate (cr, -node->bounds.origin.x, -node->bounds.origin.y);
gsk_render_node_draw (node, cr);
cairo_restore (cr);
cairo_destroy (cr);
}
gl renderer: Split out a utility function
2017-12-01 08:58:58 +00:00
surface = cairo_image_surface_create (CAIRO_FORMAT_ARGB32,
gl renderer: Ignore 0-sized fallback nodes
2018-06-26 19:40:59 +00:00
surface_width,
surface_height);
gl renderer: Fix fallback node scaling
2018-04-15 16:20:52 +00:00
cairo_surface_set_device_scale (surface, scale, scale);
gl renderer: Split out a utility function
2017-12-01 08:58:58 +00:00
cr = cairo_create (surface);
gl renderer: Render fallback nodes upside down We stuff both gl-drawn and cairo-drawn textures into the same cache, so we can't really assume that we need to draw any of them flipped or not. Fix this by drawing fallback stuff upside down and then using upside-down vertex data for everything. Fixes #1897
2019-05-18 11:45:19 +00:00
/* We draw upside down here, so it matches what GL does. */
gl renderer: Split out a utility function
2017-12-01 08:58:58 +00:00
cairo_save (cr);
gl renderer: Render fallback nodes upside down We stuff both gl-drawn and cairo-drawn textures into the same cache, so we can't really assume that we need to draw any of them flipped or not. Fix this by drawing fallback stuff upside down and then using upside-down vertex data for everything. Fixes #1897
2019-05-18 11:45:19 +00:00
cairo_scale (cr, 1, -1);
gl renderer: Properly flip scaled fallback nodes Fixes cairo nodes in hidpi setups
2019-05-30 07:12:24 +00:00
cairo_translate (cr, 0, -surface_height / scale);
gl renderer: Render recording surface untransformed Cairo can't handle the y flip apparently. Fixes #1906
2019-05-21 06:38:11 +00:00
cairo_set_source_surface (cr, rendered_surface, 0, 0);
cairo_rectangle (cr, 0, 0, surface_width, surface_height);
cairo_fill (cr);
gl renderer: Split out a utility function
2017-12-01 08:58:58 +00:00
cairo_restore (cr);
#if HIGHLIGHT_FALLBACK
gl renderer: Don't highlight cairo nodes as fallback
2018-03-30 21:32:19 +00:00
if (gsk_render_node_get_node_type (node) != GSK_CAIRO_NODE)
{
cairo_move_to (cr, 0, 0);
cairo_rectangle (cr, 0, 0, node->bounds.size.width, node->bounds.size.height);
cairo_set_source_rgba (cr, 1, 0, 0, 1);
cairo_stroke (cr);
}
gl renderer: Split out a utility function
2017-12-01 08:58:58 +00:00
#endif
cairo_destroy (cr);
/* Upload the Cairo surface to a GL texture */
texture_id = gsk_gl_driver_create_texture (self->gl_driver,
gl renderer: Ignore 0-sized fallback nodes
2018-06-26 19:40:59 +00:00
surface_width,
surface_height);
gl renderer: Split out a utility function
2017-12-01 08:58:58 +00:00
gsk_gl_driver_bind_source_texture (self->gl_driver, texture_id);
gsk_gl_driver_init_texture_with_surface (self->gl_driver,
texture_id,
surface,
GL_NEAREST, GL_NEAREST);
gl renderer: Move texture labeling below initialization Apparently genTextures and friends only "reserves names", initializing them will actually create them. Using glObjectLabel on textures before initializing them will throw a GL_INVALID_VALUE error.
2019-04-27 07:50:21 +00:00
gdk_gl_context_label_object_printf (self->gl_context, GL_TEXTURE, texture_id,
"Fallback %s %d", node->node_class->type_name, texture_id);
gl renderer: Split out a utility function
2017-12-01 08:58:58 +00:00
cairo_surface_destroy (surface);
gl renderer: Render recording surface untransformed Cairo can't handle the y flip apparently. Fixes #1906
2019-05-21 06:38:11 +00:00
cairo_surface_destroy (rendered_surface);
gl renderer: Split out a utility function
2017-12-01 08:58:58 +00:00
gl renderer: Cache rendered fallback nodes
2019-03-05 08:03:11 +00:00
gsk_gl_driver_set_texture_for_pointer (self->gl_driver, node, texture_id);
gl renderer: Split out a utility function
2017-12-01 08:58:58 +00:00
ops_set_program (builder, &self->blit_program);
ops_set_texture (builder, texture_id);
gl renderer: Render fallback nodes upside down We stuff both gl-drawn and cairo-drawn textures into the same cache, so we can't really assume that we need to draw any of them flipped or not. Fix this by drawing fallback stuff upside down and then using upside-down vertex data for everything. Fixes #1897
2019-05-18 11:45:19 +00:00
ops_draw (builder, offscreen_vertex_data);
gl renderer: Split out a utility function
2017-12-01 08:58:58 +00:00
}
gl renderer: Split out text rendering function We'll use that for text shadow nodes
2017-12-01 09:47:13 +00:00
static inline void
render_text_node (GskGLRenderer *self,
GskRenderNode *node,
RenderOpBuilder *builder,
const GdkRGBA *color,
gl renderer: Fix shadow nodes if the child is a container
2017-12-09 17:26:29 +00:00
gboolean force_color)
gl renderer: Split out text rendering function We'll use that for text shadow nodes
2017-12-01 09:47:13 +00:00
{
const PangoFont *font = gsk_text_node_peek_font (node);
const PangoGlyphInfo *glyphs = gsk_text_node_peek_glyphs (node);
gl renderer: Render everyhing according to MV scale And not the surface's scale factor. This way the magnifier works.
2018-04-11 09:20:50 +00:00
const float text_scale = ops_get_scale (builder);
gl renderer: Split out text rendering function We'll use that for text shadow nodes
2017-12-01 09:47:13 +00:00
guint num_glyphs = gsk_text_node_get_num_glyphs (node);
int i;
int x_position = 0;
rendernode: Take a graphene_point_t for the offset ... instead of 2 floats.
2019-05-19 02:08:29 +00:00
const graphene_point_t *offset = gsk_text_node_get_offset (node);
float x = offset->x + builder->dx;
float y = offset->y + builder->dy;
gl renderer: Split out text rendering function We'll use that for text shadow nodes
2017-12-01 09:47:13 +00:00
/* If the font has color glyphs, we don't need to recolor anything */
if (!force_color && font_has_color_glyphs (font))
{
ops_set_program (builder, &self->blit_program);
}
else
{
ops_set_program (builder, &self->coloring_program);
ops_set_color (builder, color);
}
/* We use one quad per character, unlike the other nodes which
* use at most one quad altogether */
for (i = 0; i < num_glyphs; i++)
{
const PangoGlyphInfo *gi = &glyphs[i];
Share glyph and icon caches Use the same texture atlases to back both the glyph and icon caches, and unify their sizes and management. Store big glyphs in separate textures, so all atlases have the same size. Tweak some of the eviction parameters. We share the caches across all GL contexts on a display, unless the GSK_NO_SHARED_CACHES env var is set.
2019-06-04 21:27:09 +00:00
GskGLCachedGlyph glyph;
gl: Don't accidentally use ints for float variables The int was floor()ing the x/y coordinates of glyphs, which could cause significant repositioning of glyphs when text was scaled via the MVP.
2018-07-08 14:52:33 +00:00
float glyph_x, glyph_y, glyph_w, glyph_h;
gl renderer: Split out text rendering function We'll use that for text shadow nodes
2017-12-01 09:47:13 +00:00
float tx, ty, tx2, ty2;
double cx;
double cy;
gl renderer: Bring back hexbox drawing
2018-01-06 12:02:31 +00:00
if (gi->glyph == PANGO_GLYPH_EMPTY)
gl renderer: Split out text rendering function We'll use that for text shadow nodes
2017-12-01 09:47:13 +00:00
continue;
Share glyph and icon caches Use the same texture atlases to back both the glyph and icon caches, and unify their sizes and management. Store big glyphs in separate textures, so all atlases have the same size. Tweak some of the eviction parameters. We share the caches across all GL contexts on a display, unless the GSK_NO_SHARED_CACHES env var is set.
2019-06-04 21:27:09 +00:00
gsk_gl_glyph_cache_lookup (self->glyph_cache,
(PangoFont *)font,
gi->glyph,
text_scale,
&glyph);
gl renderer: Split out text rendering function We'll use that for text shadow nodes
2017-12-01 09:47:13 +00:00
/* e.g. whitespace */
Share glyph and icon caches Use the same texture atlases to back both the glyph and icon caches, and unify their sizes and management. Store big glyphs in separate textures, so all atlases have the same size. Tweak some of the eviction parameters. We share the caches across all GL contexts on a display, unless the GSK_NO_SHARED_CACHES env var is set.
2019-06-04 21:27:09 +00:00
if (glyph.draw_width <= 0 || glyph.draw_height <= 0)
gl renderer: Remove an unnecessary block
2017-12-30 09:01:12 +00:00
goto next;
Share glyph and icon caches Use the same texture atlases to back both the glyph and icon caches, and unify their sizes and management. Store big glyphs in separate textures, so all atlases have the same size. Tweak some of the eviction parameters. We share the caches across all GL contexts on a display, unless the GSK_NO_SHARED_CACHES env var is set.
2019-06-04 21:27:09 +00:00
/* big glyphs are not cached */
if (!glyph.texture_id)
{
gsk_gl_glyph_cache_get_texture (self->gl_driver,
(PangoFont *)font,
gi->glyph,
text_scale,
&glyph);
g_assert (glyph.texture_id != 0);
}
gl renderer: Split out text rendering function We'll use that for text shadow nodes
2017-12-01 09:47:13 +00:00
cx = (double)(x_position + gi->geometry.x_offset) / PANGO_SCALE;
cy = (double)(gi->geometry.y_offset) / PANGO_SCALE;
Share glyph and icon caches Use the same texture atlases to back both the glyph and icon caches, and unify their sizes and management. Store big glyphs in separate textures, so all atlases have the same size. Tweak some of the eviction parameters. We share the caches across all GL contexts on a display, unless the GSK_NO_SHARED_CACHES env var is set.
2019-06-04 21:27:09 +00:00
ops_set_texture (builder, glyph.texture_id);
gl renderer: Split out text rendering function We'll use that for text shadow nodes
2017-12-01 09:47:13 +00:00
Share glyph and icon caches Use the same texture atlases to back both the glyph and icon caches, and unify their sizes and management. Store big glyphs in separate textures, so all atlases have the same size. Tweak some of the eviction parameters. We share the caches across all GL contexts on a display, unless the GSK_NO_SHARED_CACHES env var is set.
2019-06-04 21:27:09 +00:00
tx = glyph.tx;
ty = glyph.ty;
tx2 = tx + glyph.tw;
ty2 = ty + glyph.th;
gl renderer: Split out text rendering function We'll use that for text shadow nodes
2017-12-01 09:47:13 +00:00
Share glyph and icon caches Use the same texture atlases to back both the glyph and icon caches, and unify their sizes and management. Store big glyphs in separate textures, so all atlases have the same size. Tweak some of the eviction parameters. We share the caches across all GL contexts on a display, unless the GSK_NO_SHARED_CACHES env var is set.
2019-06-04 21:27:09 +00:00
glyph_x = x + cx + glyph.draw_x;
glyph_y = y + cy + glyph.draw_y;
glyph_w = glyph.draw_width;
glyph_h = glyph.draw_height;
gl renderer: Split out text rendering function We'll use that for text shadow nodes
2017-12-01 09:47:13 +00:00
gl renderer: Remove an unnecessary block
2017-12-30 09:01:12 +00:00
ops_draw (builder, (GskQuadVertex[GL_N_VERTICES]) {
{ { glyph_x, glyph_y }, { tx, ty }, },
{ { glyph_x, glyph_y + glyph_h }, { tx, ty2 }, },
{ { glyph_x + glyph_w, glyph_y }, { tx2, ty }, },
gl renderer: Split out text rendering function We'll use that for text shadow nodes
2017-12-01 09:47:13 +00:00
gl renderer: Remove an unnecessary block
2017-12-30 09:01:12 +00:00
{ { glyph_x + glyph_w, glyph_y + glyph_h }, { tx2, ty2 }, },
{ { glyph_x, glyph_y + glyph_h }, { tx, ty2 }, },
{ { glyph_x + glyph_w, glyph_y }, { tx2, ty }, },
});
gl renderer: Split out text rendering function We'll use that for text shadow nodes
2017-12-01 09:47:13 +00:00
gl renderer: Remove an unnecessary block
2017-12-30 09:01:12 +00:00
next:
gl renderer: Split out text rendering function We'll use that for text shadow nodes
2017-12-01 09:47:13 +00:00
x_position += gi->geometry.width;
}
}
gl renderer: Implement simple border nodes
2017-12-01 10:55:10 +00:00
static inline void
render_border_node (GskGLRenderer *self,
GskRenderNode *node,
RenderOpBuilder *builder)
{
gl renderer: Render everyhing according to MV scale And not the surface's scale factor. This way the magnifier works.
2018-04-11 09:20:50 +00:00
const float scale = ops_get_scale (builder);
gl renderer: Care about offset when rendering border nodes
2018-12-03 16:53:04 +00:00
const float min_x = builder->dx + node->bounds.origin.x;
const float min_y = builder->dy + node->bounds.origin.y;
gl renderer: Try to fix border rendering
2017-12-08 16:01:16 +00:00
const float max_x = min_x + node->bounds.size.width;
const float max_y = min_y + node->bounds.size.height;
gl renderer: Implement simple border nodes
2017-12-01 10:55:10 +00:00
const GdkRGBA *colors = gsk_border_node_peek_colors (node);
const GskRoundedRect *rounded_outline = gsk_border_node_peek_outline (node);
gl renderer: Handle borders in hidpi better
2017-12-09 07:57:13 +00:00
const float *og_widths = gsk_border_node_peek_widths (node);
gl renderer: Fix clipped borders Stop abusing the clip rect for borders.
2018-03-15 16:27:19 +00:00
GskRoundedRect outline;
gl renderer: Handle borders in hidpi better
2017-12-09 07:57:13 +00:00
float widths[4];
int i;
gl renderer: Implement simple border nodes
2017-12-01 10:55:10 +00:00
struct {
float w;
float h;
} sizes[4];
gl renderer: Handle borders in hidpi better
2017-12-09 07:57:13 +00:00
for (i = 0; i < 4; i ++)
widths[i] = og_widths[i];
gl renderer: Implement simple border nodes
2017-12-01 10:55:10 +00:00
/* Top left */
gl renderer: Try to fix border rendering
2017-12-08 16:01:16 +00:00
if (widths[3] > 0)
gl renderer: Default to 0px clip and border radius Finally fix the division by 0 in the clip code.
2017-12-08 21:19:52 +00:00
sizes[0].w = MAX (widths[3], rounded_outline->corner[0].width);
gl renderer: Try to fix border rendering
2017-12-08 16:01:16 +00:00
else
gl renderer: Default to 0px clip and border radius Finally fix the division by 0 in the clip code.
2017-12-08 21:19:52 +00:00
sizes[0].w = 0;
gl renderer: Try to fix border rendering
2017-12-08 16:01:16 +00:00
if (widths[0] > 0)
gl renderer: Default to 0px clip and border radius Finally fix the division by 0 in the clip code.
2017-12-08 21:19:52 +00:00
sizes[0].h = MAX (widths[0], rounded_outline->corner[0].height);
gl renderer: Try to fix border rendering
2017-12-08 16:01:16 +00:00
else
gl renderer: Default to 0px clip and border radius Finally fix the division by 0 in the clip code.
2017-12-08 21:19:52 +00:00
sizes[0].h = 0;
gl renderer: Implement simple border nodes
2017-12-01 10:55:10 +00:00
/* Top right */
gl renderer: Try to fix border rendering
2017-12-08 16:01:16 +00:00
if (widths[1] > 0)
gl renderer: Default to 0px clip and border radius Finally fix the division by 0 in the clip code.
2017-12-08 21:19:52 +00:00
sizes[1].w = MAX (widths[1], rounded_outline->corner[1].width);
gl renderer: Try to fix border rendering
2017-12-08 16:01:16 +00:00
else
gl renderer: Default to 0px clip and border radius Finally fix the division by 0 in the clip code.
2017-12-08 21:19:52 +00:00
sizes[1].w = 0;
gl renderer: Try to fix border rendering
2017-12-08 16:01:16 +00:00
if (widths[0] > 0)
gl renderer: Default to 0px clip and border radius Finally fix the division by 0 in the clip code.
2017-12-08 21:19:52 +00:00
sizes[1].h = MAX (widths[0], rounded_outline->corner[1].height);
gl renderer: Try to fix border rendering
2017-12-08 16:01:16 +00:00
else
gl renderer: Default to 0px clip and border radius Finally fix the division by 0 in the clip code.
2017-12-08 21:19:52 +00:00
sizes[1].h = 0;
gl renderer: Implement simple border nodes
2017-12-01 10:55:10 +00:00
/* Bottom right */
gl renderer: Try to fix border rendering
2017-12-08 16:01:16 +00:00
if (widths[1] > 0)
sizes[2].w = MAX (widths[1], rounded_outline->corner[2].width);
else
gl renderer: Default to 0px clip and border radius Finally fix the division by 0 in the clip code.
2017-12-08 21:19:52 +00:00
sizes[2].w = 0;
gl renderer: Try to fix border rendering
2017-12-08 16:01:16 +00:00
if (widths[2] > 0)
sizes[2].h = MAX (widths[2], rounded_outline->corner[2].height);
else
gl renderer: Default to 0px clip and border radius Finally fix the division by 0 in the clip code.
2017-12-08 21:19:52 +00:00
sizes[2].h = 0;
gl renderer: Try to fix border rendering
2017-12-08 16:01:16 +00:00
gl renderer: Implement simple border nodes
2017-12-01 10:55:10 +00:00
/* Bottom left */
gl renderer: Try to fix border rendering
2017-12-08 16:01:16 +00:00
if (widths[3] > 0)
sizes[3].w = MAX (widths[3], rounded_outline->corner[3].width);
else
gl renderer: Default to 0px clip and border radius Finally fix the division by 0 in the clip code.
2017-12-08 21:19:52 +00:00
sizes[3].w = 0;
gl renderer: Try to fix border rendering
2017-12-08 16:01:16 +00:00
if (widths[2] > 0)
sizes[3].h = MAX (widths[2], rounded_outline->corner[3].height);
else
gl renderer: Default to 0px clip and border radius Finally fix the division by 0 in the clip code.
2017-12-08 21:19:52 +00:00
sizes[3].h = 0;
gl renderer: Implement simple border nodes
2017-12-01 10:55:10 +00:00
gl renderer: Handle borders in hidpi better
2017-12-09 07:57:13 +00:00
for (i = 0; i < 4; i ++)
gl renderer: Render everyhing according to MV scale And not the surface's scale factor. This way the magnifier works.
2018-04-11 09:20:50 +00:00
widths[i] *= scale;
gl renderer: Handle borders in hidpi better
2017-12-09 07:57:13 +00:00
gl renderer: Try to fix border rendering
2017-12-08 16:01:16 +00:00
{
const GskQuadVertex side_data[4][6] = {
/* Top */
{
{ { min_x, min_y }, { 0, 1 }, }, /* Upper left */
{ { min_x + sizes[0].w, min_y + sizes[0].h }, { 0, 0 }, }, /* Lower left */
{ { max_x, min_y }, { 1, 1 }, }, /* Upper right */
{ { max_x - sizes[1].w, min_y + sizes[1].h }, { 1, 0 }, }, /* Lower right */
{ { min_x + sizes[0].w, min_y + sizes[0].h }, { 0, 0 }, }, /* Lower left */
{ { max_x, min_y }, { 1, 1 }, }, /* Upper right */
},
/* Right */
{
{ { max_x - sizes[1].w, min_y + sizes[1].h }, { 0, 1 }, }, /* Upper left */
{ { max_x - sizes[2].w, max_y - sizes[2].h }, { 0, 0 }, }, /* Lower left */
{ { max_x, min_y }, { 1, 1 }, }, /* Upper right */
{ { max_x, max_y }, { 1, 0 }, }, /* Lower right */
{ { max_x - sizes[2].w, max_y - sizes[2].h }, { 0, 0 }, }, /* Lower left */
{ { max_x, min_y }, { 1, 1 }, }, /* Upper right */
},
/* Bottom */
{
{ { min_x + sizes[3].w, max_y - sizes[3].h }, { 0, 1 }, }, /* Upper left */
{ { min_x, max_y }, { 0, 0 }, }, /* Lower left */
{ { max_x - sizes[2].w, max_y - sizes[2].h }, { 1, 1 }, }, /* Upper right */
{ { max_x, max_y }, { 1, 0 }, }, /* Lower right */
{ { min_x , max_y }, { 0, 0 }, }, /* Lower left */
{ { max_x - sizes[2].w, max_y - sizes[2].h }, { 1, 1 }, }, /* Upper right */
},
/* Left */
{
{ { min_x, min_y }, { 0, 1 }, }, /* Upper left */
{ { min_x, max_y }, { 0, 0 }, }, /* Lower left */
{ { min_x + sizes[0].w, min_y + sizes[0].h }, { 1, 1 }, }, /* Upper right */
gl renderer: Sort border sides by color
2017-12-05 12:46:29 +00:00
gl renderer: Default to 0px clip and border radius Finally fix the division by 0 in the clip code.
2017-12-08 21:19:52 +00:00
{ { min_x + sizes[3].w, max_y - sizes[3].h }, { 1, 0 }, }, /* Lower right */
gl renderer: Try to fix border rendering
2017-12-08 16:01:16 +00:00
{ { min_x, max_y }, { 0, 0 }, }, /* Lower left */
{ { min_x + sizes[0].w, min_y + sizes[0].h }, { 1, 1 }, }, /* Upper right */
}
};
int indices[4] = { 0, 1, 2, 3 };
gl renderer: Sort border sides by color
2017-12-05 12:46:29 +00:00
gl renderer: Try to fix border rendering
2017-12-08 16:01:16 +00:00
/* We sort them by color */
sort_border_sides (colors, indices);
gl renderer: Sort border sides by color
2017-12-05 12:46:29 +00:00
gl renderer: Fix clipped borders Stop abusing the clip rect for borders.
2018-03-15 16:27:19 +00:00
/* Prepare outline */
outline = *rounded_outline;
gl renderer: Use ops_transform_bounds_modelview in more places
2018-12-02 10:04:15 +00:00
ops_transform_bounds_modelview (builder, &outline.bounds, &outline.bounds);
gl renderer: Fix clipped borders Stop abusing the clip rect for borders.
2018-03-15 16:27:19 +00:00
for (i = 0; i < 4; i ++)
{
gl renderer: Render everyhing according to MV scale And not the surface's scale factor. This way the magnifier works.
2018-04-11 09:20:50 +00:00
outline.corner[i].width *= scale;
outline.corner[i].height *= scale;
gl renderer: Fix clipped borders Stop abusing the clip rect for borders.
2018-03-15 16:27:19 +00:00
}
ops_set_program (builder, &self->border_program);
gl renderer: Track border width state separately
2018-12-05 09:44:11 +00:00
ops_set_border_width (builder, widths);
ops_set_border (builder, &outline);
gl renderer: Fix clipped borders Stop abusing the clip rect for borders.
2018-03-15 16:27:19 +00:00
gl renderer: Try to fix border rendering
2017-12-08 16:01:16 +00:00
for (i = 0; i < 4; i ++)
{
if (widths[indices[i]] > 0)
{
ops_set_border_color (builder, &colors[indices[i]]);
ops_draw (builder, side_data[indices[i]]);
}
}
}
gl renderer: Implement simple border nodes
2017-12-01 10:55:10 +00:00
}
gl renderer: Use one function per node-type So a profiler can actually tell me what's slow and not just point at _add_render_ops in all cases.
2017-12-08 12:12:43 +00:00
static inline void
render_color_node (GskGLRenderer *self,
GskRenderNode *node,
RenderOpBuilder *builder,
const GskQuadVertex *vertex_data)
{
ops_set_program (builder, &self->color_program);
ops_set_color (builder, gsk_color_node_peek_color (node));
ops_draw (builder, vertex_data);
}
Consider all offscreen drawings for the icon cache
2019-06-04 17:28:59 +00:00
static inline void
upload_texture (GskGLRenderer *self,
GdkTexture *texture,
TextureRegion *out_region)
{
int texture_id;
if (texture->width <= 128 &&
gl renderer: Don't upload GL textures into the icon cache
2019-06-29 05:13:10 +00:00
texture->height <= 128 &&
!GDK_IS_GL_TEXTURE (texture))
Consider all offscreen drawings for the icon cache
2019-06-04 17:28:59 +00:00
{
graphene_rect_t trect;
gsk_gl_icon_cache_lookup_or_add (self->icon_cache,
texture,
&texture_id,
&trect);
out_region->x = trect.origin.x;
out_region->y = trect.origin.y;
out_region->x2 = out_region->x + trect.size.width;
out_region->y2 = out_region->y + trect.size.height;
}
else
{
texture_id = gsk_gl_driver_get_texture_for_texture (self->gl_driver,
texture,
GL_LINEAR,
GL_LINEAR);
out_region->x = 0;
out_region->y = 0;
out_region->x2 = 1;
out_region->y2 = 1;
}
out_region->texture_id = texture_id;
}
gl renderer: Use one function per node-type So a profiler can actually tell me what's slow and not just point at _add_render_ops in all cases.
2017-12-08 12:12:43 +00:00
static inline void
Revert "gl renderer: Limit texture node size to clip" This reverts commit 0234e8e2c94ff6b0c6f4dfcd0c940910a97eca11. This broke partially clipped-away nodes when they are being transformed, e.g. by a rotation
2018-03-19 07:08:31 +00:00
render_texture_node (GskGLRenderer *self,
GskRenderNode *node,
RenderOpBuilder *builder)
gl renderer: Use one function per node-type So a profiler can actually tell me what's slow and not just point at _add_render_ops in all cases.
2017-12-08 12:12:43 +00:00
{
GdkTexture *texture = gsk_texture_node_get_texture (node);
gl renderer: Support large textures By tiling them.
2018-03-20 08:17:26 +00:00
const int max_texture_size = gsk_gl_driver_get_max_texture_size (self->gl_driver);
const float min_x = builder->dx + node->bounds.origin.x;
const float min_y = builder->dy + node->bounds.origin.y;
const float max_x = min_x + node->bounds.size.width;
const float max_y = min_y + node->bounds.size.height;
gl renderer: Use one function per node-type So a profiler can actually tell me what's slow and not just point at _add_render_ops in all cases.
2017-12-08 12:12:43 +00:00
gl renderer: Support large textures By tiling them.
2018-03-20 08:17:26 +00:00
if (texture->width > max_texture_size || texture->height > max_texture_size)
gl renderer: add basic code to support texture tiling
2018-03-19 10:34:01 +00:00
{
gl renderer: Support large textures By tiling them.
2018-03-20 08:17:26 +00:00
const float scale_x = (max_x - min_x) / texture->width;
const float scale_y = (max_y - min_y) / texture->height;
TextureSlice *slices;
guint n_slices;
guint i;
gsk_gl_driver_slice_texture (self->gl_driver, texture, &slices, &n_slices);
gl renderer: Use one function per node-type So a profiler can actually tell me what's slow and not just point at _add_render_ops in all cases.
2017-12-08 12:12:43 +00:00
gl renderer: Support large textures By tiling them.
2018-03-20 08:17:26 +00:00
ops_set_program (builder, &self->blit_program);
for (i = 0; i < n_slices; i ++)
{
const TextureSlice *slice = &slices[i];
float x1, x2, y1, y2;
x1 = min_x + (scale_x * slice->rect.x);
x2 = x1 + (slice->rect.width * scale_x);
y1 = min_y + (scale_y * slice->rect.y);
y2 = y1 + (slice->rect.height * scale_y);
ops_set_texture (builder, slice->texture_id);
ops_draw (builder, (GskQuadVertex[GL_N_VERTICES]) {
{ { x1, y1 }, { 0, 0 }, },
{ { x1, y2 }, { 0, 1 }, },
{ { x2, y1 }, { 1, 0 }, },
{ { x2, y2 }, { 1, 1 }, },
{ { x1, y2 }, { 0, 1 }, },
{ { x2, y1 }, { 1, 0 }, },
});
}
gl renderer: add basic code to support texture tiling
2018-03-19 10:34:01 +00:00
}
else
{
Consider all offscreen drawings for the icon cache
2019-06-04 17:28:59 +00:00
TextureRegion r;
gl renderer: add basic code to support texture tiling
2018-03-19 10:34:01 +00:00
Consider all offscreen drawings for the icon cache
2019-06-04 17:28:59 +00:00
upload_texture (self, texture, &r);
gl renderer: add basic code to support texture tiling
2018-03-19 10:34:01 +00:00
ops_set_program (builder, &self->blit_program);
Consider all offscreen drawings for the icon cache
2019-06-04 17:28:59 +00:00
ops_set_texture (builder, r.texture_id);
gl renderer: Render GL textures upside down These come from an FBO so we need to flip the texture coords on the y axis, just like we do everywhere else.
2018-01-18 07:21:11 +00:00
gl renderer: add basic code to support texture tiling
2018-03-19 10:34:01 +00:00
ops_draw (builder, (GskQuadVertex[GL_N_VERTICES]) {
Consider all offscreen drawings for the icon cache
2019-06-04 17:28:59 +00:00
{ { min_x, min_y }, { r.x, r.y }, },
{ { min_x, max_y }, { r.x, r.y2 }, },
{ { max_x, min_y }, { r.x2, r.y }, },
gl renderer: Properly draw gl textures from a different context Temporarily switch to the texture's gl context, download the texture and create a new one in our context for it.
2018-03-14 11:23:38 +00:00
Consider all offscreen drawings for the icon cache
2019-06-04 17:28:59 +00:00
{ { max_x, max_y }, { r.x2, r.y2 }, },
{ { min_x, max_y }, { r.x, r.y2 }, },
{ { max_x, min_y }, { r.x2, r.y }, },
gl renderer: add basic code to support texture tiling
2018-03-19 10:34:01 +00:00
});
}
gl renderer: Use one function per node-type So a profiler can actually tell me what's slow and not just point at _add_render_ops in all cases.
2017-12-08 12:12:43 +00:00
}
static inline void
render_transform_node (GskGLRenderer *self,
GskRenderNode *node,
RenderOpBuilder *builder)
{
rendernode: Make the transform node take a GskTransform This is an attempt to push GskTransform deeper into the stack.
2019-03-01 05:35:55 +00:00
GskTransform *node_transform = gsk_transform_node_get_transform (node);
transform: Make category public API Also rename it from GskMatrixCategory to GskTransformCategory.
2019-03-01 06:51:23 +00:00
const GskTransformCategory category = gsk_transform_get_category (node_transform);
gl renderer: Use one function per node-type So a profiler can actually tell me what's slow and not just point at _add_render_ops in all cases.
2017-12-08 12:12:43 +00:00
GskRenderNode *child = gsk_transform_node_get_child (node);
gl renderer: transform nodes: offset
2018-12-03 17:29:36 +00:00
gl renderer: Use the matrix node category
2019-02-22 17:10:27 +00:00
switch (category)
gl renderer: Render non-trivial transforms to a texture This way we can e.g. render rotated clips, borders, etc.
2018-11-29 07:09:02 +00:00
{
transform: Make category public API Also rename it from GskMatrixCategory to GskTransformCategory.
2019-03-01 06:51:23 +00:00
case GSK_TRANSFORM_CATEGORY_IDENTITY:
gl renderer: Render non-trivial transforms to a texture This way we can e.g. render rotated clips, borders, etc.
2018-11-29 07:09:02 +00:00
gsk_gl_renderer_add_render_ops (self, child, builder);
gl renderer: Use the matrix node category
2019-02-22 17:10:27 +00:00
break;
transform: Make category public API Also rename it from GskMatrixCategory to GskTransformCategory.
2019-03-01 06:51:23 +00:00
case GSK_TRANSFORM_CATEGORY_2D_TRANSLATE:
gl renderer: Use the matrix node category
2019-02-22 17:10:27 +00:00
{
rendernode: Make the transform node take a GskTransform This is an attempt to push GskTransform deeper into the stack.
2019-03-01 05:35:55 +00:00
float dx, dy;
gl renderer: Use GskTransform in render ops builder for the modelview matrix. We need this later.
2019-06-02 07:55:11 +00:00
transform: Redo querying API Make the API expect a tranform of the proper category instead of doing the check ourselves and returning TRUE/FALSE. The benefit is that the mai use case is switch (transform->category) statements and in those we know the category and don't need to check TRUE/FALSE. Using the wrong matrix will now cause a g_warning().
2019-03-04 18:33:04 +00:00
gsk_transform_to_translate (node_transform, &dx, &dy);
gl renderer: Use the matrix node category
2019-02-22 17:10:27 +00:00
ops_offset (builder, dx, dy);
gsk_gl_renderer_add_render_ops (self, child, builder);
ops_offset (builder, -dx, -dy);
}
break;
transform: Make category public API Also rename it from GskMatrixCategory to GskTransformCategory.
2019-03-01 06:51:23 +00:00
case GSK_TRANSFORM_CATEGORY_2D_AFFINE:
gl renderer: Use the matrix node category
2019-02-22 17:10:27 +00:00
{
gl renderer: Use GskTransform in render ops builder for the modelview matrix. We need this later.
2019-06-02 07:55:11 +00:00
ops_push_modelview (builder, node_transform);
gl renderer: Use the matrix node category
2019-02-22 17:10:27 +00:00
gsk_gl_renderer_add_render_ops (self, child, builder);
ops_pop_modelview (builder);
}
break;
transform: Make category public API Also rename it from GskMatrixCategory to GskTransformCategory.
2019-03-01 06:51:23 +00:00
case GSK_TRANSFORM_CATEGORY_UNKNOWN:
case GSK_TRANSFORM_CATEGORY_ANY:
case GSK_TRANSFORM_CATEGORY_3D:
case GSK_TRANSFORM_CATEGORY_2D:
gl renderer: Use the matrix node category
2019-02-22 17:10:27 +00:00
default:
{
gl renderer: Stop determining the matrix category ourselves Use the category we get from transform nodes and add ops_ API to supply one when we set a graphene_matrix_t directly.
2019-02-23 06:50:51 +00:00
if (node_supports_transform (child))
{
gl renderer: Use GskTransform in render ops builder for the modelview matrix. We need this later.
2019-06-02 07:55:11 +00:00
ops_push_modelview (builder, node_transform);
gl renderer: Stop determining the matrix category ourselves Use the category we get from transform nodes and add ops_ API to supply one when we set a graphene_matrix_t directly.
2019-02-23 06:50:51 +00:00
gsk_gl_renderer_add_render_ops (self, child, builder);
gl renderer: Apply transform only for final texture drawing We don't want the new transform while drawing things on a texture. Instead, only apply the new transform matrix when adding the final texture drawing ops. This fixes the stack cube rotation transition to at least look somewhat better.
2019-03-31 04:16:16 +00:00
ops_pop_modelview (builder);
gl renderer: Use the matrix node category
2019-02-22 17:10:27 +00:00
}
else
{
gl renderer: Apply transform only for final texture drawing We don't want the new transform while drawing things on a texture. Instead, only apply the new transform matrix when adding the final texture drawing ops. This fixes the stack cube rotation transition to at least look somewhat better.
2019-03-31 04:16:16 +00:00
const float min_x = child->bounds.origin.x;
const float min_y = child->bounds.origin.y;
const float max_x = min_x + child->bounds.size.width;
const float max_y = min_y + child->bounds.size.height;
Consider all offscreen drawings for the icon cache
2019-06-04 17:28:59 +00:00
TextureRegion region;
gl renderer: Apply transform only for final texture drawing We don't want the new transform while drawing things on a texture. Instead, only apply the new transform matrix when adding the final texture drawing ops. This fixes the stack cube rotation transition to at least look somewhat better.
2019-03-31 04:16:16 +00:00
gboolean is_offscreen;
gl renderer: Stop determining the matrix category ourselves Use the category we get from transform nodes and add ops_ API to supply one when we set a graphene_matrix_t directly.
2019-02-23 06:50:51 +00:00
/* For non-trivial transforms, we draw everything on a texture and then
* draw the texture transformed. */
/* TODO: We should compute a modelview containing only the "non-trivial"
* part (e.g. the rotation) and use that. We want to keep the scale
* for the texture.
*/
add_offscreen_ops (self, builder,
&child->bounds,
child,
Consider all offscreen drawings for the icon cache
2019-06-04 17:28:59 +00:00
&region, &is_offscreen,
gl renderer: Stop determining the matrix category ourselves Use the category we get from transform nodes and add ops_ API to supply one when we set a graphene_matrix_t directly.
2019-02-23 06:50:51 +00:00
RESET_CLIP | RESET_OPACITY);
gl renderer: Apply transform only for final texture drawing We don't want the new transform while drawing things on a texture. Instead, only apply the new transform matrix when adding the final texture drawing ops. This fixes the stack cube rotation transition to at least look somewhat better.
2019-03-31 04:16:16 +00:00
gl renderer: Use GskTransform in render ops builder for the modelview matrix. We need this later.
2019-06-02 07:55:11 +00:00
ops_push_modelview (builder, node_transform);
Consider all offscreen drawings for the icon cache
2019-06-04 17:28:59 +00:00
ops_set_texture (builder, region.texture_id);
gl renderer: Stop determining the matrix category ourselves Use the category we get from transform nodes and add ops_ API to supply one when we set a graphene_matrix_t directly.
2019-02-23 06:50:51 +00:00
ops_set_program (builder, &self->blit_program);
if (is_offscreen)
{
const GskQuadVertex offscreen_vertex_data[GL_N_VERTICES] = {
Consider all offscreen drawings for the icon cache
2019-06-04 17:28:59 +00:00
{ { min_x, min_y }, { region.x, region.y2 }, },
{ { min_x, max_y }, { region.x, region.y }, },
{ { max_x, min_y }, { region.x2, region.y2 }, },
gl renderer: Stop determining the matrix category ourselves Use the category we get from transform nodes and add ops_ API to supply one when we set a graphene_matrix_t directly.
2019-02-23 06:50:51 +00:00
Consider all offscreen drawings for the icon cache
2019-06-04 17:28:59 +00:00
{ { max_x, max_y }, { region.x2, region.y }, },
{ { min_x, max_y }, { region.x, region.y }, },
{ { max_x, min_y }, { region.x2, region.y2 }, },
gl renderer: Stop determining the matrix category ourselves Use the category we get from transform nodes and add ops_ API to supply one when we set a graphene_matrix_t directly.
2019-02-23 06:50:51 +00:00
};
ops_draw (builder, offscreen_vertex_data);
}
else
{
const GskQuadVertex onscreen_vertex_data[GL_N_VERTICES] = {
Consider all offscreen drawings for the icon cache
2019-06-04 17:28:59 +00:00
{ { min_x, min_y }, { region.x, region.y }, },
{ { min_x, max_y }, { region.x, region.y2 }, },
{ { max_x, min_y }, { region.x2, region.y }, },
gl renderer: Stop determining the matrix category ourselves Use the category we get from transform nodes and add ops_ API to supply one when we set a graphene_matrix_t directly.
2019-02-23 06:50:51 +00:00
Consider all offscreen drawings for the icon cache
2019-06-04 17:28:59 +00:00
{ { max_x, max_y }, { region.x2, region.y2 }, },
{ { min_x, max_y }, { region.x, region.y2 }, },
{ { max_x, min_y }, { region.x2, region.y }, },
gl renderer: Stop determining the matrix category ourselves Use the category we get from transform nodes and add ops_ API to supply one when we set a graphene_matrix_t directly.
2019-02-23 06:50:51 +00:00
};
ops_draw (builder, onscreen_vertex_data);
}
gl renderer: Use the matrix node category
2019-02-22 17:10:27 +00:00
gl renderer: Apply transform only for final texture drawing We don't want the new transform while drawing things on a texture. Instead, only apply the new transform matrix when adding the final texture drawing ops. This fixes the stack cube rotation transition to at least look somewhat better.
2019-03-31 04:16:16 +00:00
ops_pop_modelview (builder);
}
gl renderer: Use the matrix node category
2019-02-22 17:10:27 +00:00
}
gl renderer: Render non-trivial transforms to a texture This way we can e.g. render rotated clips, borders, etc.
2018-11-29 07:09:02 +00:00
}
gl renderer: Use one function per node-type So a profiler can actually tell me what's slow and not just point at _add_render_ops in all cases.
2017-12-08 12:12:43 +00:00
}
static inline void
render_opacity_node (GskGLRenderer *self,
GskRenderNode *node,
RenderOpBuilder *builder)
{
gl renderer: Fix opacity nodes with overlapping child nodes
2019-07-13 15:35:59 +00:00
GskRenderNode *child = gsk_opacity_node_get_child (node);
const float opacity = gsk_opacity_node_get_opacity (node);
gl renderer: Use one function per node-type So a profiler can actually tell me what's slow and not just point at _add_render_ops in all cases.
2017-12-08 12:12:43 +00:00
float prev_opacity;
gl renderer: Fix opacity nodes with overlapping child nodes
2019-07-13 15:35:59 +00:00
if (gsk_render_node_get_node_type (child) == GSK_CONTAINER_NODE)
{
const float min_x = builder->dx + node->bounds.origin.x;
const float min_y = builder->dy + node->bounds.origin.y;
const float max_x = min_x + node->bounds.size.width;
const float max_y = min_y + node->bounds.size.height;
gboolean is_offscreen;
TextureRegion region;
/* The semantics of an opacity node mandate that when, e.g., two color nodes overlap,
* there may not be any blending between them */
add_offscreen_ops (self, builder, &child->bounds,
child,
&region, &is_offscreen,
FORCE_OFFSCREEN | RESET_OPACITY | RESET_CLIP);
prev_opacity = ops_set_opacity (builder,
builder->current_opacity * opacity);
ops_set_program (builder, &self->blit_program);
ops_set_texture (builder, region.texture_id);
ops_draw (builder, (GskQuadVertex[GL_N_VERTICES]) {
{ { min_x, min_y }, { region.x, region.y2 }, },
{ { min_x, max_y }, { region.x, region.y }, },
{ { max_x, min_y }, { region.x2, region.y2 }, },
{ { max_x, max_y }, { region.x2, region.y }, },
{ { min_x, max_y }, { region.x, region.y }, },
{ { max_x, min_y }, { region.x2, region.y2 }, },
});
}
else
{
prev_opacity = ops_set_opacity (builder,
builder->current_opacity * opacity);
gl renderer: Use one function per node-type So a profiler can actually tell me what's slow and not just point at _add_render_ops in all cases.
2017-12-08 12:12:43 +00:00
gl renderer: Fix opacity nodes with overlapping child nodes
2019-07-13 15:35:59 +00:00
gsk_gl_renderer_add_render_ops (self, child, builder);
}
gl renderer: Use one function per node-type So a profiler can actually tell me what's slow and not just point at _add_render_ops in all cases.
2017-12-08 12:12:43 +00:00
ops_set_opacity (builder, prev_opacity);
}
static inline void
render_linear_gradient_node (GskGLRenderer *self,
GskRenderNode *node,
RenderOpBuilder *builder,
const GskQuadVertex *vertex_data)
{
RenderOp op;
int n_color_stops = MIN (8, gsk_linear_gradient_node_get_n_color_stops (node));
const GskColorStop *stops = gsk_linear_gradient_node_peek_color_stops (node);
const graphene_point_t *start = gsk_linear_gradient_node_peek_start (node);
const graphene_point_t *end = gsk_linear_gradient_node_peek_end (node);
int i;
for (i = 0; i < n_color_stops; i ++)
{
const GskColorStop *stop = stops + i;
op.linear_gradient.color_stops[(i * 4) + 0] = stop->color.red;
op.linear_gradient.color_stops[(i * 4) + 1] = stop->color.green;
op.linear_gradient.color_stops[(i * 4) + 2] = stop->color.blue;
op.linear_gradient.color_stops[(i * 4) + 3] = stop->color.alpha;
op.linear_gradient.color_offsets[i] = stop->offset;
}
ops_set_program (builder, &self->linear_gradient_program);
op.op = OP_CHANGE_LINEAR_GRADIENT;
op.linear_gradient.n_color_stops = n_color_stops;
op.linear_gradient.start_point = *start;
gl renderer: Linear gradients: offset
2018-12-03 17:03:34 +00:00
op.linear_gradient.start_point.x += builder->dx;
op.linear_gradient.start_point.y += builder->dy;
gl renderer: Use one function per node-type So a profiler can actually tell me what's slow and not just point at _add_render_ops in all cases.
2017-12-08 12:12:43 +00:00
op.linear_gradient.end_point = *end;
gl renderer: Linear gradients: offset
2018-12-03 17:03:34 +00:00
op.linear_gradient.end_point.x += builder->dx;
op.linear_gradient.end_point.y += builder->dy;
gl renderer: Use one function per node-type So a profiler can actually tell me what's slow and not just point at _add_render_ops in all cases.
2017-12-08 12:12:43 +00:00
ops_add (builder, &op);
ops_draw (builder, vertex_data);
}
static inline void
render_clip_node (GskGLRenderer *self,
GskRenderNode *node,
RenderOpBuilder *builder)
{
GskRenderNode *child = gsk_clip_node_get_child (node);
graphene_rect_t transformed_clip;
graphene_rect_t intersection;
GskRoundedRect child_clip;
transformed_clip = *gsk_clip_node_peek_clip (node);
gl renderer: Use ops_transform_bounds_modelview in more places
2018-12-02 10:04:15 +00:00
ops_transform_bounds_modelview (builder, &transformed_clip, &transformed_clip);
gl renderer: Use one function per node-type So a profiler can actually tell me what's slow and not just point at _add_render_ops in all cases.
2017-12-08 12:12:43 +00:00
graphene_rect_intersection (&transformed_clip,
gl renderer: Add a clip stack So we can check that the currently set clip is the first one and now intersect with it. This first clip is always the entire viewport or the entire render_area and we don't want to end up drawing things to a texture because of it.
2018-12-30 14:25:01 +00:00
&builder->current_clip->bounds,
gl renderer: Use one function per node-type So a profiler can actually tell me what's slow and not just point at _add_render_ops in all cases.
2017-12-08 12:12:43 +00:00
&intersection);
gsk_rounded_rect_init_from_rect (&child_clip, &intersection, 0.0f);
gl renderer: Add a clip stack So we can check that the currently set clip is the first one and now intersect with it. This first clip is always the entire viewport or the entire render_area and we don't want to end up drawing things to a texture because of it.
2018-12-30 14:25:01 +00:00
ops_push_clip (builder, &child_clip);
gl renderer: Use one function per node-type So a profiler can actually tell me what's slow and not just point at _add_render_ops in all cases.
2017-12-08 12:12:43 +00:00
gsk_gl_renderer_add_render_ops (self, child, builder);
gl renderer: Add a clip stack So we can check that the currently set clip is the first one and now intersect with it. This first clip is always the entire viewport or the entire render_area and we don't want to end up drawing things to a texture because of it.
2018-12-30 14:25:01 +00:00
ops_pop_clip (builder);
gl renderer: Use one function per node-type So a profiler can actually tell me what's slow and not just point at _add_render_ops in all cases.
2017-12-08 12:12:43 +00:00
}
gl renderer: Partially implement rounded rect intersection Some rounded rect intersections can actually be done and even expressed as a single rounded rectangle.
2019-02-24 08:14:23 +00:00
static inline void
get_inner_rect (const GskRoundedRect *rect,
graphene_rect_t *out)
{
const float left = MAX (rect->corner[GSK_CORNER_TOP_LEFT].width,
rect->corner[GSK_CORNER_BOTTOM_LEFT].width);
const float top = MAX (rect->corner[GSK_CORNER_TOP_LEFT].height,
rect->corner[GSK_CORNER_TOP_RIGHT].height);
out->origin.x = rect->bounds.origin.x + left;
out->origin.y = rect->bounds.origin.y + top;
out->size.width = rect->bounds.size.width - left -
MAX (rect->corner[GSK_CORNER_TOP_RIGHT].width,
rect->corner[GSK_CORNER_BOTTOM_RIGHT].width);
out->size.height = rect->bounds.size.height - top -
MAX (rect->corner[GSK_CORNER_BOTTOM_LEFT].height,
rect->corner[GSK_CORNER_BOTTOM_RIGHT].height);
}
/* Best effort intersection of two rounded rectangles */
gl renderer: Add a clip stack So we can check that the currently set clip is the first one and now intersect with it. This first clip is always the entire viewport or the entire render_area and we don't want to end up drawing things to a texture because of it.
2018-12-30 14:25:01 +00:00
static gboolean
gl renderer: Partially implement rounded rect intersection Some rounded rect intersections can actually be done and even expressed as a single rounded rectangle.
2019-02-24 08:14:23 +00:00
gsk_rounded_rect_intersection (const GskRoundedRect *outer,
const GskRoundedRect *inner,
gl renderer: Add a clip stack So we can check that the currently set clip is the first one and now intersect with it. This first clip is always the entire viewport or the entire render_area and we don't want to end up drawing things to a texture because of it.
2018-12-30 14:25:01 +00:00
GskRoundedRect *out_intersection)
{
gl renderer: Partially implement rounded rect intersection Some rounded rect intersections can actually be done and even expressed as a single rounded rectangle.
2019-02-24 08:14:23 +00:00
const graphene_rect_t *outer_bounds = &outer->bounds;
const graphene_rect_t *inner_bounds = &inner->bounds;
graphene_rect_t outer_inner;
graphene_rect_t inner_inner;
gboolean contained_x;
gboolean contained_y;
gl renderer: Fix rounded rect intersection code Test case attached. Fixes #1920
2019-06-02 06:31:44 +00:00
get_inner_rect (outer, &outer_inner);
if (graphene_rect_contains_rect (&outer_inner, inner_bounds))
gl renderer: Add a clip stack So we can check that the currently set clip is the first one and now intersect with it. This first clip is always the entire viewport or the entire render_area and we don't want to end up drawing things to a texture because of it.
2018-12-30 14:25:01 +00:00
{
gl renderer: Partially implement rounded rect intersection Some rounded rect intersections can actually be done and even expressed as a single rounded rectangle.
2019-02-24 08:14:23 +00:00
*out_intersection = *inner;
gl renderer: Add a clip stack So we can check that the currently set clip is the first one and now intersect with it. This first clip is always the entire viewport or the entire render_area and we don't want to end up drawing things to a texture because of it.
2018-12-30 14:25:01 +00:00
return TRUE;
}
gl renderer: Partially implement rounded rect intersection Some rounded rect intersections can actually be done and even expressed as a single rounded rectangle.
2019-02-24 08:14:23 +00:00
get_inner_rect (inner, &inner_inner);
gl renderer: Add a clip stack So we can check that the currently set clip is the first one and now intersect with it. This first clip is always the entire viewport or the entire render_area and we don't want to end up drawing things to a texture because of it.
2018-12-30 14:25:01 +00:00
gl renderer: Partially implement rounded rect intersection Some rounded rect intersections can actually be done and even expressed as a single rounded rectangle.
2019-02-24 08:14:23 +00:00
contained_x = outer_inner.origin.x <= inner_inner.origin.x &&
(outer_inner.origin.x + outer_inner.size.width) > (inner_inner.origin.x +
inner_inner.size.width);
gl renderer: Add a clip stack So we can check that the currently set clip is the first one and now intersect with it. This first clip is always the entire viewport or the entire render_area and we don't want to end up drawing things to a texture because of it.
2018-12-30 14:25:01 +00:00
gl renderer: Partially implement rounded rect intersection Some rounded rect intersections can actually be done and even expressed as a single rounded rectangle.
2019-02-24 08:14:23 +00:00
contained_y = outer_inner.origin.y <= inner_inner.origin.y &&
(outer_inner.origin.y + outer_inner.size.height) > (inner_inner.origin.y +
inner_inner.size.height);
gl renderer: Add a clip stack So we can check that the currently set clip is the first one and now intersect with it. This first clip is always the entire viewport or the entire render_area and we don't want to end up drawing things to a texture because of it.
2018-12-30 14:25:01 +00:00
gl renderer: Partially implement rounded rect intersection Some rounded rect intersections can actually be done and even expressed as a single rounded rectangle.
2019-02-24 08:14:23 +00:00
if (contained_x && !contained_y)
{
/* The intersection is @inner, but cut-off and with the cut-off corners
* set to size 0 */
*out_intersection = *inner;
if (inner_bounds->origin.y < outer_bounds->origin.y)
{
/* Set top corners to 0 */
graphene_rect_intersection (outer_bounds, inner_bounds, &out_intersection->bounds);
graphene_size_init (&out_intersection->corner[GSK_CORNER_TOP_LEFT], 0, 0);
graphene_size_init (&out_intersection->corner[GSK_CORNER_TOP_RIGHT], 0, 0);
graphene_size_init_from_size (&out_intersection->corner[GSK_CORNER_BOTTOM_LEFT],
&inner->corner[GSK_CORNER_BOTTOM_LEFT]);
graphene_size_init_from_size (&out_intersection->corner[GSK_CORNER_BOTTOM_RIGHT],
&inner->corner[GSK_CORNER_BOTTOM_RIGHT]);
return TRUE;
}
else if (inner_bounds->origin.y + inner_bounds->size.height >
outer_bounds->origin.y + outer_bounds->size.height)
{
/* Set bottom corners to 0 */
graphene_rect_intersection (outer_bounds, inner_bounds, &out_intersection->bounds);
graphene_size_init (&out_intersection->corner[GSK_CORNER_BOTTOM_LEFT], 0, 0);
graphene_size_init (&out_intersection->corner[GSK_CORNER_BOTTOM_RIGHT], 0, 0);
graphene_size_init_from_size (&out_intersection->corner[GSK_CORNER_TOP_LEFT],
&inner->corner[GSK_CORNER_TOP_LEFT]);
graphene_size_init_from_size (&out_intersection->corner[GSK_CORNER_TOP_RIGHT],
&inner->corner[GSK_CORNER_TOP_RIGHT]);
return TRUE;
}
}
else if (!contained_x && contained_y)
{
/* The intersection is @inner, but cut-off and with the cut-off corners
* set to size 0 */
*out_intersection = *inner;
if (inner_bounds->origin.x < outer_bounds->origin.x)
{
/* Set left corners to 0 */
graphene_rect_intersection (outer_bounds, inner_bounds, &out_intersection->bounds);
graphene_size_init (&out_intersection->corner[GSK_CORNER_TOP_LEFT], 0, 0);
graphene_size_init (&out_intersection->corner[GSK_CORNER_BOTTOM_LEFT], 0, 0);
graphene_size_init_from_size (&out_intersection->corner[GSK_CORNER_TOP_RIGHT],
&inner->corner[GSK_CORNER_TOP_RIGHT]);
graphene_size_init_from_size (&out_intersection->corner[GSK_CORNER_BOTTOM_RIGHT],
&inner->corner[GSK_CORNER_BOTTOM_RIGHT]);
return TRUE;
}
else if (inner_bounds->origin.x + inner_bounds->size.width >
outer_bounds->origin.x + outer_bounds->size.width)
{
/* Set right corners to 0 */
graphene_rect_intersection (outer_bounds, inner_bounds, &out_intersection->bounds);
graphene_size_init (&out_intersection->corner[GSK_CORNER_TOP_RIGHT], 0, 0);
graphene_size_init (&out_intersection->corner[GSK_CORNER_BOTTOM_RIGHT], 0, 0);
graphene_size_init_from_size (&out_intersection->corner[GSK_CORNER_TOP_LEFT],
&inner->corner[GSK_CORNER_TOP_LEFT]);
graphene_size_init_from_size (&out_intersection->corner[GSK_CORNER_BOTTOM_LEFT],
&inner->corner[GSK_CORNER_BOTTOM_LEFT]);
return TRUE;
}
}
/* Actually not possible or just too much work. */
return FALSE;
}
gl renderer: Add a clip stack So we can check that the currently set clip is the first one and now intersect with it. This first clip is always the entire viewport or the entire render_area and we don't want to end up drawing things to a texture because of it.
2018-12-30 14:25:01 +00:00
gl renderer: Use one function per node-type So a profiler can actually tell me what's slow and not just point at _add_render_ops in all cases.
2017-12-08 12:12:43 +00:00
static inline void
gl renderer: Draw rounded clip child to a texture And then clip the texture using the current (maybe also rounded) clip. This way, the result is correct. We don't necessarily have to do the offscreen drawing in any case, but got the safe route for now.
2018-03-14 11:36:32 +00:00
render_rounded_clip_node (GskGLRenderer *self,
GskRenderNode *node,
RenderOpBuilder *builder)
gl renderer: Use one function per node-type So a profiler can actually tell me what's slow and not just point at _add_render_ops in all cases.
2017-12-08 12:12:43 +00:00
{
gl renderer: Render everyhing according to MV scale And not the surface's scale factor. This way the magnifier works.
2018-04-11 09:20:50 +00:00
const float scale = ops_get_scale (builder);
gl renderer: Fix rounded clips in hidpi
2018-03-15 10:01:53 +00:00
GskRoundedRect child_clip = *gsk_rounded_clip_node_peek_clip (node);
gl renderer: Don't draw all rounded clip nodes to a texture We only need to do that if the rounde clip node intersects with the outer one.
2018-04-11 15:57:57 +00:00
GskRoundedRect transformed_clip;
gl renderer: Use one function per node-type So a profiler can actually tell me what's slow and not just point at _add_render_ops in all cases.
2017-12-08 12:12:43 +00:00
GskRenderNode *child = gsk_rounded_clip_node_get_child (node);
gl renderer: Add a clip stack So we can check that the currently set clip is the first one and now intersect with it. This first clip is always the entire viewport or the entire render_area and we don't want to end up drawing things to a texture because of it.
2018-12-30 14:25:01 +00:00
GskRoundedRect intersection;
gboolean need_offscreen;
gl renderer: Fix rounded clips in hidpi
2018-03-15 10:01:53 +00:00
int i;
gl renderer: Use one function per node-type So a profiler can actually tell me what's slow and not just point at _add_render_ops in all cases.
2017-12-08 12:12:43 +00:00
gl renderer: Don't draw all rounded clip nodes to a texture We only need to do that if the rounde clip node intersects with the outer one.
2018-04-11 15:57:57 +00:00
transformed_clip = child_clip;
gl renderer: Use ops_transform_bounds_modelview in more places
2018-12-02 10:04:15 +00:00
ops_transform_bounds_modelview (builder, &child_clip.bounds, &transformed_clip.bounds);
gl renderer: Fix rounded clips in hidpi
2018-03-15 10:01:53 +00:00
gl renderer: Add a clip stack So we can check that the currently set clip is the first one and now intersect with it. This first clip is always the entire viewport or the entire render_area and we don't want to end up drawing things to a texture because of it.
2018-12-30 14:25:01 +00:00
if (!ops_has_clip (builder))
{
intersection = transformed_clip;
need_offscreen = FALSE;
}
else
{
need_offscreen = !gsk_rounded_rect_intersection (builder->current_clip,
&transformed_clip,
&intersection);
}
if (!need_offscreen)
gl renderer: Fix rounded clips in hidpi
2018-03-15 10:01:53 +00:00
{
gl renderer: Don't draw all rounded clip nodes to a texture We only need to do that if the rounde clip node intersects with the outer one.
2018-04-11 15:57:57 +00:00
/* If they don't intersect at all, we can simply set
* the new clip and add the render ops */
for (i = 0; i < 4; i ++)
{
gl renderer: Add a clip stack So we can check that the currently set clip is the first one and now intersect with it. This first clip is always the entire viewport or the entire render_area and we don't want to end up drawing things to a texture because of it.
2018-12-30 14:25:01 +00:00
intersection.corner[i].width *= scale;
intersection.corner[i].height *= scale;
gl renderer: Don't draw all rounded clip nodes to a texture We only need to do that if the rounde clip node intersects with the outer one.
2018-04-11 15:57:57 +00:00
}
gl renderer: Add a clip stack So we can check that the currently set clip is the first one and now intersect with it. This first clip is always the entire viewport or the entire render_area and we don't want to end up drawing things to a texture because of it.
2018-12-30 14:25:01 +00:00
ops_push_clip (builder, &intersection);
gl renderer: Don't draw all rounded clip nodes to a texture We only need to do that if the rounde clip node intersects with the outer one.
2018-04-11 15:57:57 +00:00
gsk_gl_renderer_add_render_ops (self, child, builder);
gl renderer: Add a clip stack So we can check that the currently set clip is the first one and now intersect with it. This first clip is always the entire viewport or the entire render_area and we don't want to end up drawing things to a texture because of it.
2018-12-30 14:25:01 +00:00
ops_pop_clip (builder);
gl renderer: Fix rounded clips in hidpi
2018-03-15 10:01:53 +00:00
}
gl renderer: Add a clip stack So we can check that the currently set clip is the first one and now intersect with it. This first clip is always the entire viewport or the entire render_area and we don't want to end up drawing things to a texture because of it.
2018-12-30 14:25:01 +00:00
else
gl renderer: Don't draw all rounded clip nodes to a texture We only need to do that if the rounde clip node intersects with the outer one.
2018-04-11 15:57:57 +00:00
{
gl renderer: Clip nodes: offset
2018-12-03 17:11:09 +00:00
const float min_x = builder->dx + node->bounds.origin.x;
const float min_y = builder->dy + node->bounds.origin.y;
const float max_x = min_x + node->bounds.size.width;
const float max_y = min_y + node->bounds.size.height;
gl renderer: Don't draw all rounded clip nodes to a texture We only need to do that if the rounde clip node intersects with the outer one.
2018-04-11 15:57:57 +00:00
graphene_matrix_t scale_matrix;
gboolean is_offscreen;
Consider all offscreen drawings for the icon cache
2019-06-04 17:28:59 +00:00
TextureRegion region;
gl renderer: Don't draw all rounded clip nodes to a texture We only need to do that if the rounde clip node intersects with the outer one.
2018-04-11 15:57:57 +00:00
/* NOTE: We are *not* transforming the clip by the current modelview here.
* We instead draw the untransformed clip to a texture and then transform
* that texture.
*
* We do, however, apply the scale factor to the child clip of course.
*/
graphene_matrix_init_scale (&scale_matrix, scale, scale, 1.0f);
graphene_matrix_transform_bounds (&scale_matrix, &child_clip.bounds, &child_clip.bounds);
/* Increase corner radius size by scale factor */
for (i = 0; i < 4; i ++)
{
child_clip.corner[i].width *= scale;
child_clip.corner[i].height *= scale;
}
gl renderer: Fix rounded clips in hidpi
2018-03-15 10:01:53 +00:00
gl renderer: Add a clip stack So we can check that the currently set clip is the first one and now intersect with it. This first clip is always the entire viewport or the entire render_area and we don't want to end up drawing things to a texture because of it.
2018-12-30 14:25:01 +00:00
ops_push_clip (builder, &child_clip);
gl renderer: Refactor add_offscreen_ops Use a graphene_rect_t for the node bounds instead of 4 floats. This makes it simpler to pass the size in without the offset applied.
2018-12-02 08:05:50 +00:00
add_offscreen_ops (self, builder, &node->bounds,
gl renderer: Don't draw all rounded clip nodes to a texture We only need to do that if the rounde clip node intersects with the outer one.
2018-04-11 15:57:57 +00:00
child,
Consider all offscreen drawings for the icon cache
2019-06-04 17:28:59 +00:00
&region, &is_offscreen,
gl renderer: Support (not) resetting the opacity for offscreen nodes We usually want to do that, but it's wrong for e.g. crossfade nodes.
2019-01-18 12:06:41 +00:00
FORCE_OFFSCREEN | RESET_OPACITY);
gl renderer: Add a clip stack So we can check that the currently set clip is the first one and now intersect with it. This first clip is always the entire viewport or the entire render_area and we don't want to end up drawing things to a texture because of it.
2018-12-30 14:25:01 +00:00
ops_pop_clip (builder);
gl renderer: Use one function per node-type So a profiler can actually tell me what's slow and not just point at _add_render_ops in all cases.
2017-12-08 12:12:43 +00:00
gl renderer: Don't draw all rounded clip nodes to a texture We only need to do that if the rounde clip node intersects with the outer one.
2018-04-11 15:57:57 +00:00
ops_set_program (builder, &self->blit_program);
Consider all offscreen drawings for the icon cache
2019-06-04 17:28:59 +00:00
ops_set_texture (builder, region.texture_id);
gl renderer: Draw rounded clip child to a texture And then clip the texture using the current (maybe also rounded) clip. This way, the result is correct. We don't necessarily have to do the offscreen drawing in any case, but got the safe route for now.
2018-03-14 11:36:32 +00:00
gl renderer: Don't draw all rounded clip nodes to a texture We only need to do that if the rounde clip node intersects with the outer one.
2018-04-11 15:57:57 +00:00
ops_draw (builder, (GskQuadVertex[GL_N_VERTICES]) {
{ { min_x, min_y }, { 0, 1 }, },
{ { min_x, max_y }, { 0, 0 }, },
{ { max_x, min_y }, { 1, 1 }, },
gl renderer: Fix opacity nodes with overlapping child nodes
2019-07-13 15:35:59 +00:00
gl renderer: Don't draw all rounded clip nodes to a texture We only need to do that if the rounde clip node intersects with the outer one.
2018-04-11 15:57:57 +00:00
{ { max_x, max_y }, { 1, 0 }, },
{ { min_x, max_y }, { 0, 0 }, },
{ { max_x, min_y }, { 1, 1 }, },
});
}
/* Else this node is entirely out of the current clip node and we don't draw it anyway. */
gl renderer: Use one function per node-type So a profiler can actually tell me what's slow and not just point at _add_render_ops in all cases.
2017-12-08 12:12:43 +00:00
}
static inline void
render_color_matrix_node (GskGLRenderer *self,
GskRenderNode *node,
RenderOpBuilder *builder,
const GskQuadVertex *vertex_data)
{
gl renderer: Use offsets for more node types
2018-05-27 12:41:56 +00:00
const float min_x = builder->dx + node->bounds.origin.x;
const float min_y = builder->dy + node->bounds.origin.y;
gl renderer: Use one function per node-type So a profiler can actually tell me what's slow and not just point at _add_render_ops in all cases.
2017-12-08 12:12:43 +00:00
const float max_x = min_x + node->bounds.size.width;
const float max_y = min_y + node->bounds.size.height;
gl renderer: Declare color matrix child separately Otherwise I'm doing this all the time when debugging.
2019-03-31 05:50:33 +00:00
GskRenderNode *child = gsk_color_matrix_node_get_child (node);
Consider all offscreen drawings for the icon cache
2019-06-04 17:28:59 +00:00
TextureRegion region;
gl renderer: Use one function per node-type So a profiler can actually tell me what's slow and not just point at _add_render_ops in all cases.
2017-12-08 12:12:43 +00:00
gboolean is_offscreen;
gl renderer: Add offscreen ops without offset applied When doing color matrix nodes. This fixes color matrix node with scale = 2.
2018-12-02 07:17:34 +00:00
add_offscreen_ops (self, builder,
gl renderer: Refactor add_offscreen_ops Use a graphene_rect_t for the node bounds instead of 4 floats. This makes it simpler to pass the size in without the offset applied.
2018-12-02 08:05:50 +00:00
&node->bounds,
gl renderer: Declare color matrix child separately Otherwise I'm doing this all the time when debugging.
2019-03-31 05:50:33 +00:00
child,
Consider all offscreen drawings for the icon cache
2019-06-04 17:28:59 +00:00
&region, &is_offscreen,
gl renderer: Support (not) resetting the opacity for offscreen nodes We usually want to do that, but it's wrong for e.g. crossfade nodes.
2019-01-18 12:06:41 +00:00
RESET_CLIP | RESET_OPACITY);
gl renderer: Use one function per node-type So a profiler can actually tell me what's slow and not just point at _add_render_ops in all cases.
2017-12-08 12:12:43 +00:00
ops_set_program (builder, &self->color_matrix_program);
ops_set_color_matrix (builder,
gsk_color_matrix_node_peek_color_matrix (node),
gsk_color_matrix_node_peek_color_offset (node));
Consider all offscreen drawings for the icon cache
2019-06-04 17:28:59 +00:00
ops_set_texture (builder, region.texture_id);
gl renderer: Use one function per node-type So a profiler can actually tell me what's slow and not just point at _add_render_ops in all cases.
2017-12-08 12:12:43 +00:00
if (is_offscreen)
{
build: Reintroduce warning flags from autotools Some of the flags got lost in the meson transition or were demoted from error flags to warning flags. This commit reintroduces them. It also includes fixes for the code that had warnings with those flags. The big one being -Wshadow.
2019-01-22 03:30:47 +00:00
GskQuadVertex offscreen_vertex_data[GL_N_VERTICES] = {
Consider all offscreen drawings for the icon cache
2019-06-04 17:28:59 +00:00
{ { min_x, min_y }, { region.x, region.y2 }, },
{ { min_x, max_y }, { region.x, region.y }, },
{ { max_x, min_y }, { region.x2, region.y2 }, },
gl renderer: Use one function per node-type So a profiler can actually tell me what's slow and not just point at _add_render_ops in all cases.
2017-12-08 12:12:43 +00:00
Consider all offscreen drawings for the icon cache
2019-06-04 17:28:59 +00:00
{ { max_x, max_y }, { region.x2, region.y }, },
{ { min_x, max_y }, { region.x, region.y }, },
{ { max_x, min_y }, { region.x2, region.y2 }, },
gl renderer: Use one function per node-type So a profiler can actually tell me what's slow and not just point at _add_render_ops in all cases.
2017-12-08 12:12:43 +00:00
};
build: Reintroduce warning flags from autotools Some of the flags got lost in the meson transition or were demoted from error flags to warning flags. This commit reintroduces them. It also includes fixes for the code that had warnings with those flags. The big one being -Wshadow.
2019-01-22 03:30:47 +00:00
ops_draw (builder, offscreen_vertex_data);
gl renderer: Use one function per node-type So a profiler can actually tell me what's slow and not just point at _add_render_ops in all cases.
2017-12-08 12:12:43 +00:00
}
else
{
Consider all offscreen drawings for the icon cache
2019-06-04 17:28:59 +00:00
const GskQuadVertex onscreen_vertex_data[GL_N_VERTICES] = {
{ { min_x, min_y }, { region.x, region.y }, },
{ { min_x, max_y }, { region.x, region.y2 }, },
{ { max_x, min_y }, { region.x2, region.y }, },
{ { max_x, max_y }, { region.x2, region.y2 }, },
{ { min_x, max_y }, { region.x, region.y2 }, },
{ { max_x, min_y }, { region.x2, region.y }, },
};
ops_draw (builder, onscreen_vertex_data);
gl renderer: Use one function per node-type So a profiler can actually tell me what's slow and not just point at _add_render_ops in all cases.
2017-12-08 12:12:43 +00:00
}
}
static inline void
render_blur_node (GskGLRenderer *self,
GskRenderNode *node,
RenderOpBuilder *builder,
const GskQuadVertex *vertex_data)
{
gl renderer: Don't forget the offset when rendering blur nodes
2019-01-05 08:18:27 +00:00
const float min_x = builder->dx + node->bounds.origin.x;
const float min_y = builder->dy + node->bounds.origin.y;
gl renderer: Use one function per node-type So a profiler can actually tell me what's slow and not just point at _add_render_ops in all cases.
2017-12-08 12:12:43 +00:00
const float max_x = min_x + node->bounds.size.width;
const float max_y = min_y + node->bounds.size.height;
gl renderer: Fix blur nodes with radius 0
2019-05-07 15:20:11 +00:00
const float blur_radius = gsk_blur_node_get_radius (node);
Consider all offscreen drawings for the icon cache
2019-06-04 17:28:59 +00:00
TextureRegion region;
gl renderer: Use one function per node-type So a profiler can actually tell me what's slow and not just point at _add_render_ops in all cases.
2017-12-08 12:12:43 +00:00
gboolean is_offscreen;
RenderOp op;
gl renderer: Don't forget the offset when rendering blur nodes
2019-01-05 08:18:27 +00:00
gl renderer: Fix blur nodes with radius 0
2019-05-07 15:20:11 +00:00
if (blur_radius <= 0)
{
gsk_gl_renderer_add_render_ops (self, gsk_blur_node_get_child (node), builder);
return;
}
gl renderer: Force blur shadow node children offscreen This broke the overlay blur demoe when resizing the window to a size that would completely move the image below a button, causing the GtkSnapshot code to remove the clip node below the blur node.
2019-01-13 07:21:58 +00:00
/* TODO(perf): We're forcing the child offscreen even if it's a texture
* so the resulting offscreen texture is bigger by the gaussian blur factor
* (see gsk_blur_node_new), but we didn't have to do that if the blur
* shader could handle that situation. */
gl renderer: Refactor add_offscreen_ops Use a graphene_rect_t for the node bounds instead of 4 floats. This makes it simpler to pass the size in without the offset applied.
2018-12-02 08:05:50 +00:00
add_offscreen_ops (self, builder,
&node->bounds,
gl renderer: Use one function per node-type So a profiler can actually tell me what's slow and not just point at _add_render_ops in all cases.
2017-12-08 12:12:43 +00:00
gsk_blur_node_get_child (node),
Consider all offscreen drawings for the icon cache
2019-06-04 17:28:59 +00:00
&region, &is_offscreen,
gl renderer: Support (not) resetting the opacity for offscreen nodes We usually want to do that, but it's wrong for e.g. crossfade nodes.
2019-01-18 12:06:41 +00:00
RESET_CLIP | FORCE_OFFSCREEN | RESET_OPACITY);
gl renderer: Use one function per node-type So a profiler can actually tell me what's slow and not just point at _add_render_ops in all cases.
2017-12-08 12:12:43 +00:00
ops_set_program (builder, &self->blur_program);
op.op = OP_CHANGE_BLUR;
graphene_size_init_from_size (&op.blur.size, &node->bounds.size);
gl renderer: Replace a redundant function call We're already getting the radius from the node above.
2019-07-19 14:42:56 +00:00
op.blur.radius = blur_radius;
gl renderer: Use one function per node-type So a profiler can actually tell me what's slow and not just point at _add_render_ops in all cases.
2017-12-08 12:12:43 +00:00
ops_add (builder, &op);
Consider all offscreen drawings for the icon cache
2019-06-04 17:28:59 +00:00
ops_set_texture (builder, region.texture_id);
gl renderer: Use one function per node-type So a profiler can actually tell me what's slow and not just point at _add_render_ops in all cases.
2017-12-08 12:12:43 +00:00
if (is_offscreen)
{
build: Reintroduce warning flags from autotools Some of the flags got lost in the meson transition or were demoted from error flags to warning flags. This commit reintroduces them. It also includes fixes for the code that had warnings with those flags. The big one being -Wshadow.
2019-01-22 03:30:47 +00:00
GskQuadVertex offscreen_vertex_data[GL_N_VERTICES] = {
gl renderer: Use one function per node-type So a profiler can actually tell me what's slow and not just point at _add_render_ops in all cases.
2017-12-08 12:12:43 +00:00
{ { min_x, min_y }, { 0, 1 }, },
{ { min_x, max_y }, { 0, 0 }, },
{ { max_x, min_y }, { 1, 1 }, },
gl renderer: Replace a redundant function call We're already getting the radius from the node above.
2019-07-19 14:42:56 +00:00
gl renderer: Use one function per node-type So a profiler can actually tell me what's slow and not just point at _add_render_ops in all cases.
2017-12-08 12:12:43 +00:00
{ { max_x, max_y }, { 1, 0 }, },
{ { min_x, max_y }, { 0, 0 }, },
{ { max_x, min_y }, { 1, 1 }, },
};
build: Reintroduce warning flags from autotools Some of the flags got lost in the meson transition or were demoted from error flags to warning flags. This commit reintroduces them. It also includes fixes for the code that had warnings with those flags. The big one being -Wshadow.
2019-01-22 03:30:47 +00:00
ops_draw (builder, offscreen_vertex_data);
gl renderer: Use one function per node-type So a profiler can actually tell me what's slow and not just point at _add_render_ops in all cases.
2017-12-08 12:12:43 +00:00
}
else
{
ops_draw (builder, vertex_data);
}
}
static inline void
render_inset_shadow_node (GskGLRenderer *self,
GskRenderNode *node,
RenderOpBuilder *builder,
const GskQuadVertex *vertex_data)
{
gl renderer: Render everyhing according to MV scale And not the surface's scale factor. This way the magnifier works.
2018-04-11 09:20:50 +00:00
const float scale = ops_get_scale (builder);
gl renderer: Use one function per node-type So a profiler can actually tell me what's slow and not just point at _add_render_ops in all cases.
2017-12-08 12:12:43 +00:00
RenderOp op;
/* TODO: Implement blurred inset shadows as well */
if (gsk_inset_shadow_node_get_blur_radius (node) > 0)
{
gl renderer: Render fallback nodes upside down We stuff both gl-drawn and cairo-drawn textures into the same cache, so we can't really assume that we need to draw any of them flipped or not. Fix this by drawing fallback stuff upside down and then using upside-down vertex data for everything. Fixes #1897
2019-05-18 11:45:19 +00:00
render_fallback_node (self, node, builder);
gl renderer: Use one function per node-type So a profiler can actually tell me what's slow and not just point at _add_render_ops in all cases.
2017-12-08 12:12:43 +00:00
return;
}
op.op = OP_CHANGE_INSET_SHADOW;
rgba_to_float (gsk_inset_shadow_node_peek_color (node), op.inset_shadow.color);
gl renderer: Fix inset and outset shadows in hidpi
2017-12-09 08:41:52 +00:00
rounded_rect_to_floats (self, builder,
gsk_inset_shadow_node_peek_outline (node),
gl renderer: Use one function per node-type So a profiler can actually tell me what's slow and not just point at _add_render_ops in all cases.
2017-12-08 12:12:43 +00:00
op.inset_shadow.outline,
op.inset_shadow.corner_widths,
op.inset_shadow.corner_heights);
gl renderer: Render everyhing according to MV scale And not the surface's scale factor. This way the magnifier works.
2018-04-11 09:20:50 +00:00
op.inset_shadow.radius = gsk_inset_shadow_node_get_blur_radius (node) * scale;
op.inset_shadow.spread = gsk_inset_shadow_node_get_spread (node) * scale;
op.inset_shadow.offset[0] = gsk_inset_shadow_node_get_dx (node) * scale;
op.inset_shadow.offset[1] = -gsk_inset_shadow_node_get_dy (node) * scale;
gl renderer: Use one function per node-type So a profiler can actually tell me what's slow and not just point at _add_render_ops in all cases.
2017-12-08 12:12:43 +00:00
ops_set_program (builder, &self->inset_shadow_program);
ops_add (builder, &op);
ops_draw (builder, vertex_data);
}
gl renderer: Render unblurred outset shadows differently We don't need to draw anything to a texure for those.
2018-01-15 09:55:40 +00:00
static inline void
render_unblurred_outset_shadow_node (GskGLRenderer *self,
GskRenderNode *node,
RenderOpBuilder *builder,
const GskQuadVertex *vertex_data)
{
gl renderer: Render everyhing according to MV scale And not the surface's scale factor. This way the magnifier works.
2018-04-11 09:20:50 +00:00
const float scale = ops_get_scale (builder);
gl renderer: Render unblurred outset shadows differently We don't need to draw anything to a texure for those.
2018-01-15 09:55:40 +00:00
const float spread = gsk_outset_shadow_node_get_spread (node);
GskRoundedRect r = *gsk_outset_shadow_node_peek_outline (node);
RenderOp op;
op.op = OP_CHANGE_UNBLURRED_OUTSET_SHADOW;
rgba_to_float (gsk_outset_shadow_node_peek_color (node), op.unblurred_outset_shadow.color);
gsk_rounded_rect_shrink (&r, -spread, -spread, -spread, -spread);
rounded_rect_to_floats (self, builder,
&r,
op.unblurred_outset_shadow.outline,
op.unblurred_outset_shadow.corner_widths,
op.unblurred_outset_shadow.corner_heights);
gl renderer: Render everyhing according to MV scale And not the surface's scale factor. This way the magnifier works.
2018-04-11 09:20:50 +00:00
op.unblurred_outset_shadow.spread = gsk_outset_shadow_node_get_spread (node) * scale;
op.unblurred_outset_shadow.offset[0] = gsk_outset_shadow_node_get_dx (node) * scale;
op.unblurred_outset_shadow.offset[1] = -gsk_outset_shadow_node_get_dy (node) * scale;
gl renderer: Render unblurred outset shadows differently We don't need to draw anything to a texure for those.
2018-01-15 09:55:40 +00:00
ops_set_program (builder, &self->unblurred_outset_shadow_program);
ops_add (builder, &op);
ops_draw (builder, vertex_data);
}
gl renderer: Use one function per node-type So a profiler can actually tell me what's slow and not just point at _add_render_ops in all cases.
2017-12-08 12:12:43 +00:00
static inline void
render_outset_shadow_node (GskGLRenderer *self,
GskRenderNode *node,
gl renderer: Remove unused parameter
2017-12-28 17:57:53 +00:00
RenderOpBuilder *builder)
gl renderer: Use one function per node-type So a profiler can actually tell me what's slow and not just point at _add_render_ops in all cases.
2017-12-08 12:12:43 +00:00
{
gl renderer: try doing outset box shadows Still fall back in cases we can't handle that way.
2017-12-21 17:09:32 +00:00
const GskRoundedRect *outline = gsk_outset_shadow_node_peek_outline (node);
GskRoundedRect offset_outline;
const float blur_radius = gsk_outset_shadow_node_get_blur_radius (node);
gl renderer: draw all outset shadows Instead of falling back to cairo for most of them.
2017-12-28 15:41:32 +00:00
const float blur_extra = gsk_cairo_blur_compute_pixels (blur_radius);
gl renderer: try doing outset box shadows Still fall back in cases we can't handle that way.
2017-12-21 17:09:32 +00:00
const float spread = gsk_outset_shadow_node_get_spread (node);
const float dx = gsk_outset_shadow_node_get_dx (node);
const float dy = gsk_outset_shadow_node_get_dy (node);
gl renderer: Outset shadow nodes: offset
2018-12-03 16:56:46 +00:00
const float min_x = builder->dx + outline->bounds.origin.x - spread - blur_extra / 2.0;
const float min_y = builder->dy + outline->bounds.origin.y - spread - blur_extra / 2.0;
gl renderer: draw all outset shadows Instead of falling back to cairo for most of them.
2017-12-28 15:41:32 +00:00
const float max_x = min_x + outline->bounds.size.width + (spread + blur_extra/2.0) * 2;
const float max_y = min_y + outline->bounds.size.height + (spread + blur_extra/2.0) * 2;
gl renderer: try doing outset box shadows Still fall back in cases we can't handle that way.
2017-12-21 17:09:32 +00:00
float texture_width, texture_height;
gl renderer: Use one function per node-type So a profiler can actually tell me what's slow and not just point at _add_render_ops in all cases.
2017-12-08 12:12:43 +00:00
RenderOp op;
gl renderer: try doing outset box shadows Still fall back in cases we can't handle that way.
2017-12-21 17:09:32 +00:00
graphene_matrix_t identity;
graphene_matrix_t prev_projection;
graphene_rect_t prev_viewport;
graphene_matrix_t item_proj;
gl renderer: Pull a few declarations into the closest scope
2018-07-15 15:52:34 +00:00
int blurred_texture_id;
gl renderer: Cache blurred outset shadow nodes Since these are particularly expensive to render and we have a pretty big one used in every client-side decorated window.
2018-07-08 18:08:15 +00:00
int cached_tid;
gl renderer: try doing outset box shadows Still fall back in cases we can't handle that way.
2017-12-21 17:09:32 +00:00
/* offset_outline is the minimal outline we need to draw the given drop shadow,
* enlarged by the spread and offset by the blur radius. */
offset_outline = *outline;
gl renderer: draw all outset shadows Instead of falling back to cairo for most of them.
2017-12-28 15:41:32 +00:00
/* Shrink our outline to the minimum size that can still hold all the border radii */
gl renderer: try doing outset box shadows Still fall back in cases we can't handle that way.
2017-12-21 17:09:32 +00:00
gsk_rounded_rect_shrink_to_minimum (&offset_outline);
gl renderer: draw all outset shadows Instead of falling back to cairo for most of them.
2017-12-28 15:41:32 +00:00
/* Increase by the spread */
gl renderer: try doing outset box shadows Still fall back in cases we can't handle that way.
2017-12-21 17:09:32 +00:00
gsk_rounded_rect_shrink (&offset_outline, -spread, -spread, -spread, -spread);
gl renderer: draw all outset shadows Instead of falling back to cairo for most of them.
2017-12-28 15:41:32 +00:00
/* No we need to incorporate the blur radius; since we blur an edge an equal blur_extra/2.0
* on both sides, the minimum side of both width and height needs to be blur_extra */
offset_outline.bounds.size.width = MAX (offset_outline.bounds.size.width, blur_extra);
offset_outline.bounds.size.height = MAX (offset_outline.bounds.size.height, blur_extra);
/* For the center part, we add a few pixels */
gl renderer: try doing outset box shadows Still fall back in cases we can't handle that way.
2017-12-21 17:09:32 +00:00
offset_outline.bounds.size.width += SHADOW_EXTRA_SIZE;
offset_outline.bounds.size.height += SHADOW_EXTRA_SIZE;
gl renderer: draw all outset shadows Instead of falling back to cairo for most of them.
2017-12-28 15:41:32 +00:00
offset_outline.bounds.origin.x = blur_extra / 2.0f;
offset_outline.bounds.origin.y = blur_extra / 2.0f;
gl renderer: try doing outset box shadows Still fall back in cases we can't handle that way.
2017-12-21 17:09:32 +00:00
gl renderer: draw all outset shadows Instead of falling back to cairo for most of them.
2017-12-28 15:41:32 +00:00
texture_width = offset_outline.bounds.size.width + blur_extra;
texture_height = offset_outline.bounds.size.height + blur_extra;
gl renderer: try doing outset box shadows Still fall back in cases we can't handle that way.
2017-12-21 17:09:32 +00:00
gl renderer: Cache blurred outset shadow nodes Since these are particularly expensive to render and we have a pretty big one used in every client-side decorated window.
2018-07-08 18:08:15 +00:00
cached_tid = gsk_gl_shadow_cache_get_texture_id (&self->shadow_cache,
self->gl_driver,
&offset_outline,
blur_radius);
if (cached_tid == 0)
{
gl renderer: Pull a few declarations into the closest scope
2018-07-15 15:52:34 +00:00
int texture_id, render_target;
int blurred_render_target;
int prev_render_target;
gl renderer: Add a clip stack So we can check that the currently set clip is the first one and now intersect with it. This first clip is always the entire viewport or the entire render_area and we don't want to end up drawing things to a texture because of it.
2018-12-30 14:25:01 +00:00
GskRoundedRect blit_clip;
gl renderer: Pull a few declarations into the closest scope
2018-07-15 15:52:34 +00:00
gl renderer: Make creating render targets easier
2019-05-22 05:10:57 +00:00
gsk_gl_driver_create_render_target (self->gl_driver, texture_width, texture_height,
&texture_id, &render_target);
gl renderer: Move texture labeling below initialization Apparently genTextures and friends only "reserves names", initializing them will actually create them. Using glObjectLabel on textures before initializing them will throw a GL_INVALID_VALUE error.
2019-04-27 07:50:21 +00:00
gdk_gl_context_label_object_printf (self->gl_context, GL_TEXTURE, texture_id,
"Outset Shadow Temp %d", texture_id);
GskGLRenderer: Label various gl objects This means the names are more useful in tools like renderdoc.
2019-04-24 11:27:43 +00:00
gdk_gl_context_label_object_printf (self->gl_context, GL_FRAMEBUFFER, render_target,
"Outset Shadow FB Temp %d", render_target);
gl renderer: Cache blurred outset shadow nodes Since these are particularly expensive to render and we have a pretty big one used in every client-side decorated window.
2018-07-08 18:08:15 +00:00
graphene_matrix_init_ortho (&item_proj,
0, texture_width, 0, texture_height,
ORTHO_NEAR_PLANE, ORTHO_FAR_PLANE);
graphene_matrix_scale (&item_proj, 1, -1, 1);
graphene_matrix_init_identity (&identity);
prev_render_target = ops_set_render_target (builder, render_target);
op.op = OP_CLEAR;
ops_add (builder, &op);
prev_projection = ops_set_projection (builder, &item_proj);
gl renderer: Use GskTransform in render ops builder for the modelview matrix. We need this later.
2019-06-02 07:55:11 +00:00
ops_set_modelview (builder, NULL); /* Modelview */
gl renderer: Cache blurred outset shadow nodes Since these are particularly expensive to render and we have a pretty big one used in every client-side decorated window.
2018-07-08 18:08:15 +00:00
prev_viewport = ops_set_viewport (builder, &GRAPHENE_RECT_INIT (0, 0, texture_width, texture_height));
/* Draw outline */
ops_set_program (builder, &self->color_program);
gl renderer: Add a clip stack So we can check that the currently set clip is the first one and now intersect with it. This first clip is always the entire viewport or the entire render_area and we don't want to end up drawing things to a texture because of it.
2018-12-30 14:25:01 +00:00
ops_push_clip (builder, &offset_outline);
gl renderer: Cache blurred outset shadow nodes Since these are particularly expensive to render and we have a pretty big one used in every client-side decorated window.
2018-07-08 18:08:15 +00:00
ops_set_color (builder, gsk_outset_shadow_node_peek_color (node));
ops_draw (builder, (GskQuadVertex[GL_N_VERTICES]) {
{ { 0, }, { 0, 1 }, },
{ { 0, texture_height }, { 0, 0 }, },
{ { texture_width, }, { 1, 1 }, },
gl renderer: Use one function per node-type So a profiler can actually tell me what's slow and not just point at _add_render_ops in all cases.
2017-12-08 12:12:43 +00:00
gl renderer: Cache blurred outset shadow nodes Since these are particularly expensive to render and we have a pretty big one used in every client-side decorated window.
2018-07-08 18:08:15 +00:00
{ { texture_width, texture_height }, { 1, 0 }, },
{ { 0, texture_height }, { 0, 0 }, },
{ { texture_width, }, { 1, 1 }, },
});
gl renderer: try doing outset box shadows Still fall back in cases we can't handle that way.
2017-12-21 17:09:32 +00:00
gl renderer: Make creating render targets easier
2019-05-22 05:10:57 +00:00
gsk_gl_driver_create_render_target (self->gl_driver, texture_width, texture_height,
&blurred_texture_id, &blurred_render_target);
gl renderer: Move texture labeling below initialization Apparently genTextures and friends only "reserves names", initializing them will actually create them. Using glObjectLabel on textures before initializing them will throw a GL_INVALID_VALUE error.
2019-04-27 07:50:21 +00:00
gdk_gl_context_label_object_printf (self->gl_context, GL_TEXTURE, blurred_texture_id,
"Outset Shadow Cache %d", blurred_texture_id);
GskGLRenderer: Label various gl objects This means the names are more useful in tools like renderdoc.
2019-04-24 11:27:43 +00:00
gdk_gl_context_label_object_printf (self->gl_context, GL_FRAMEBUFFER, render_target,
"Outset Shadow Cache FB %d", render_target);
gl renderer: try doing outset box shadows Still fall back in cases we can't handle that way.
2017-12-21 17:09:32 +00:00
gl renderer: Cache blurred outset shadow nodes Since these are particularly expensive to render and we have a pretty big one used in every client-side decorated window.
2018-07-08 18:08:15 +00:00
ops_set_render_target (builder, blurred_render_target);
gl renderer: Add a clip stack So we can check that the currently set clip is the first one and now intersect with it. This first clip is always the entire viewport or the entire render_area and we don't want to end up drawing things to a texture because of it.
2018-12-30 14:25:01 +00:00
ops_pop_clip (builder);
gl renderer: Cache blurred outset shadow nodes Since these are particularly expensive to render and we have a pretty big one used in every client-side decorated window.
2018-07-08 18:08:15 +00:00
op.op = OP_CLEAR;
ops_add (builder, &op);
gl renderer: try doing outset box shadows Still fall back in cases we can't handle that way.
2017-12-21 17:09:32 +00:00
gl renderer: Cache blurred outset shadow nodes Since these are particularly expensive to render and we have a pretty big one used in every client-side decorated window.
2018-07-08 18:08:15 +00:00
gsk_rounded_rect_init_from_rect (&blit_clip,
&GRAPHENE_RECT_INIT (0, 0, texture_width, texture_height), 0.0f);
gl renderer: try doing outset box shadows Still fall back in cases we can't handle that way.
2017-12-21 17:09:32 +00:00
gl renderer: Cache blurred outset shadow nodes Since these are particularly expensive to render and we have a pretty big one used in every client-side decorated window.
2018-07-08 18:08:15 +00:00
ops_set_program (builder, &self->blur_program);
op.op = OP_CHANGE_BLUR;
op.blur.size.width = texture_width;
op.blur.size.height = texture_height;
op.blur.radius = blur_radius;
ops_add (builder, &op);
gl renderer: Avoid some code duplication
2017-12-31 07:45:40 +00:00
gl renderer: Add a clip stack So we can check that the currently set clip is the first one and now intersect with it. This first clip is always the entire viewport or the entire render_area and we don't want to end up drawing things to a texture because of it.
2018-12-30 14:25:01 +00:00
ops_push_clip (builder, &blit_clip);
gl renderer: Cache blurred outset shadow nodes Since these are particularly expensive to render and we have a pretty big one used in every client-side decorated window.
2018-07-08 18:08:15 +00:00
ops_set_texture (builder, texture_id);
ops_draw (builder, (GskQuadVertex[GL_N_VERTICES]) {
{ { 0, 0 }, { 0, 1 }, },
{ { 0, texture_height }, { 0, 0 }, },
{ { texture_width, 0 }, { 1, 1 }, },
gl renderer: Avoid some code duplication
2017-12-31 07:45:40 +00:00
gl renderer: Cache blurred outset shadow nodes Since these are particularly expensive to render and we have a pretty big one used in every client-side decorated window.
2018-07-08 18:08:15 +00:00
{ { texture_width, texture_height }, { 1, 0 }, },
{ { 0, texture_height }, { 0, 0 }, },
{ { texture_width, 0 }, { 1, 1 }, },
});
gl renderer: Avoid some code duplication
2017-12-31 07:45:40 +00:00
gl renderer: try doing outset box shadows Still fall back in cases we can't handle that way.
2017-12-21 17:09:32 +00:00
gl renderer: Add a clip stack So we can check that the currently set clip is the first one and now intersect with it. This first clip is always the entire viewport or the entire render_area and we don't want to end up drawing things to a texture because of it.
2018-12-30 14:25:01 +00:00
ops_pop_clip (builder);
gl renderer: Cache blurred outset shadow nodes Since these are particularly expensive to render and we have a pretty big one used in every client-side decorated window.
2018-07-08 18:08:15 +00:00
ops_set_viewport (builder, &prev_viewport);
gl renderer: Use stack to keep track of modelview matrix So we can avoid calculating metadata for matrices all the time.
2018-11-26 16:52:35 +00:00
ops_pop_modelview (builder);
gl renderer: Cache blurred outset shadow nodes Since these are particularly expensive to render and we have a pretty big one used in every client-side decorated window.
2018-07-08 18:08:15 +00:00
ops_set_projection (builder, &prev_projection);
ops_set_render_target (builder, prev_render_target);
gl renderer: Make creating render targets easier
2019-05-22 05:10:57 +00:00
gsk_gl_driver_mark_texture_permanent (self->gl_driver, blurred_texture_id);
gl renderer: Cache blurred outset shadow nodes Since these are particularly expensive to render and we have a pretty big one used in every client-side decorated window.
2018-07-08 18:08:15 +00:00
gsk_gl_shadow_cache_commit (&self->shadow_cache,
&offset_outline,
blur_radius,
blurred_texture_id);
}
else
{
blurred_texture_id = cached_tid;
}
gl renderer: Use one function per node-type So a profiler can actually tell me what's slow and not just point at _add_render_ops in all cases.
2017-12-08 12:12:43 +00:00
gl renderer: try doing outset box shadows Still fall back in cases we can't handle that way.
2017-12-21 17:09:32 +00:00
ops_set_program (builder, &self->outset_shadow_program);
ops_set_texture (builder, blurred_texture_id);
gl renderer: Use one function per node-type So a profiler can actually tell me what's slow and not just point at _add_render_ops in all cases.
2017-12-08 12:12:43 +00:00
op.op = OP_CHANGE_OUTSET_SHADOW;
gl renderer: Fix outset shadow outline transform This fixes hidpi blurred outset shadows
2018-01-23 20:44:33 +00:00
rounded_rect_to_floats (self, builder,
outline,
op.outset_shadow.outline,
op.outset_shadow.corner_widths,
op.outset_shadow.corner_heights);
gl renderer: Use one function per node-type So a profiler can actually tell me what's slow and not just point at _add_render_ops in all cases.
2017-12-08 12:12:43 +00:00
ops_add (builder, &op);
gl renderer: try doing outset box shadows Still fall back in cases we can't handle that way.
2017-12-21 17:09:32 +00:00
/* We use the one outset shadow op from above to draw all 8 sides/corners. */
{
const GskRoundedRect *o = &offset_outline;
gl renderer: draw all outset shadows Instead of falling back to cairo for most of them.
2017-12-28 15:41:32 +00:00
float top_height = MAX (o->corner[0].height, o->corner[1].height);
float bottom_height = MAX (o->corner[2].height, o->corner[3].height);
float left_width = MAX (o->corner[0].width, o->corner[3].width);
float right_width = MAX (o->corner[1].width, o->corner[2].width);
float x1, x2, y1, y2, tx1, tx2, ty1, ty2;
top_height = MAX (top_height, blur_extra / 2.0f) + (blur_extra / 2.0f);
bottom_height = MAX (bottom_height, blur_extra / 2.0f) + (blur_extra / 2.0f);
left_width = MAX (left_width, blur_extra / 2.0f) + (blur_extra / 2.0f);
right_width = MAX (right_width, blur_extra / 2.0f) + (blur_extra / 2.0f);
gl renderer: try doing outset box shadows Still fall back in cases we can't handle that way.
2017-12-21 17:09:32 +00:00
/* Top left */
gl renderer: Only draw what we have to
2017-12-28 17:00:59 +00:00
if (top_height > 0 && left_width > 0)
{
x1 = min_x + dx;
x2 = min_x + dx + left_width;
y1 = min_y + dy;
y2 = min_y + dy + top_height;
tx1 = 0;
tx2 = left_width / texture_width;
ty1 = 1 - (top_height / texture_height);
ty2 = 1;
ops_draw (builder, (GskQuadVertex[GL_N_VERTICES]) {
{ { x1, y1 }, { tx1, ty2 }, },
{ { x1, y2 }, { tx1, ty1 }, },
{ { x2, y1 }, { tx2, ty2 }, },
{ { x2, y2 }, { tx2, ty1 }, },
{ { x1, y2 }, { tx1, ty1 }, },
{ { x2, y1 }, { tx2, ty2 }, },
});
}
gl renderer: try doing outset box shadows Still fall back in cases we can't handle that way.
2017-12-21 17:09:32 +00:00
/* Top right */
gl renderer: Only draw what we have to
2017-12-28 17:00:59 +00:00
if (top_height > 0 && right_width > 0)
{
x1 = max_x + dx - right_width;
x2 = max_x + dx;
y1 = min_y + dy;
y2 = min_y + dy + top_height;
tx1 = 1 - (right_width / texture_width);
tx2 = 1;
ty1 = 1 - (top_height / texture_height);
ty2 = 1;
ops_draw (builder, (GskQuadVertex[GL_N_VERTICES]) {
{ { x1, y1 }, { tx1, ty2 }, },
{ { x1, y2 }, { tx1, ty1 }, },
{ { x2, y1 }, { tx2, ty2 }, },
{ { x2, y2 }, { tx2, ty1 }, },
{ { x1, y2 }, { tx1, ty1 }, },
{ { x2, y1 }, { tx2, ty2 }, },
});
}
gl renderer: try doing outset box shadows Still fall back in cases we can't handle that way.
2017-12-21 17:09:32 +00:00
/* Bottom right */
gl renderer: Only draw what we have to
2017-12-28 17:00:59 +00:00
if (bottom_height > 0 && left_width > 0)
{
x1 = max_x + dx - right_width;
x2 = max_x + dx;
y1 = max_y + dy - bottom_height;
y2 = max_y + dy;
tx1 = 1 - (right_width / texture_width);
tx2 = 1;
ty1 = 0;
ty2 = (bottom_height / texture_height);
ops_draw (builder, (GskQuadVertex[GL_N_VERTICES]) {
{ { x1, y1 }, { tx1, ty2 }, },
{ { x1, y2 }, { tx1, ty1 }, },
{ { x2, y1 }, { tx2, ty2 }, },
{ { x2, y2 }, { tx2, ty1 }, },
{ { x1, y2 }, { tx1, ty1 }, },
{ { x2, y1 }, { tx2, ty2 }, },
});
}
gl renderer: try doing outset box shadows Still fall back in cases we can't handle that way.
2017-12-21 17:09:32 +00:00
/* Bottom left */
gl renderer: Only draw what we have to
2017-12-28 17:00:59 +00:00
if (bottom_height > 0 && left_width > 0)
{
x1 = min_x + dx;
x2 = min_x + dx + left_width;
y1 = max_y + dy - bottom_height;
y2 = max_y + dy;
tx1 = 0;
tx2 = left_width / texture_width;
ty1 = 0;
ty2 = bottom_height / texture_height;
ops_draw (builder, (GskQuadVertex[GL_N_VERTICES]) {
{ { x1, y1 }, { tx1, ty2 }, },
{ { x1, y2 }, { tx1, ty1 }, },
{ { x2, y1 }, { tx2, ty2 }, },
{ { x2, y2 }, { tx2, ty1 }, },
{ { x1, y2 }, { tx1, ty1 }, },
{ { x2, y1 }, { tx2, ty2 }, },
});
}
gl renderer: try doing outset box shadows Still fall back in cases we can't handle that way.
2017-12-21 17:09:32 +00:00
/* Left side */
gl renderer: Only draw what we have to
2017-12-28 17:00:59 +00:00
if (left_width > 0)
{
x1 = min_x + dx;
x2 = min_x + dx + left_width;
y1 = min_y + dy + top_height;
y2 = max_y + dy - bottom_height;
tx1 = 0;
tx2 = left_width / texture_width;
ty1 = 0.5f - SHADOW_EXTRA_SIZE / 2.0f / texture_height;
ty2 = ty1 + (SHADOW_EXTRA_SIZE / texture_height);
ops_draw (builder, (GskQuadVertex[GL_N_VERTICES]) {
{ { x1, y1 }, { tx1, ty2 }, },
{ { x1, y2 }, { tx1, ty1 }, },
{ { x2, y1 }, { tx2, ty2 }, },
{ { x2, y2 }, { tx2, ty1 }, },
{ { x1, y2 }, { tx1, ty1 }, },
{ { x2, y1 }, { tx2, ty2 }, },
});
}
gl renderer: try doing outset box shadows Still fall back in cases we can't handle that way.
2017-12-21 17:09:32 +00:00
/* Right side */
gl renderer: Only draw what we have to
2017-12-28 17:00:59 +00:00
if (right_width > 0)
{
x1 = max_x + dx - right_width;
x2 = max_x + dx;
y1 = min_y + dy + top_height;
y2 = max_y + dy - bottom_height;
tx1 = 1 - (right_width / texture_width);
tx2 = 1;
ty1 = 0.5f - SHADOW_EXTRA_SIZE / 2.0f / texture_height;
ty2 = ty1 + (SHADOW_EXTRA_SIZE / texture_height);
ops_draw (builder, (GskQuadVertex[GL_N_VERTICES]) {
{ { x1, y1 }, { tx1, ty2 }, },
{ { x1, y2 }, { tx1, ty1 }, },
{ { x2, y1 }, { tx2, ty2 }, },
{ { x2, y2 }, { tx2, ty1 }, },
{ { x1, y2 }, { tx1, ty1 }, },
{ { x2, y1 }, { tx2, ty2 }, },
});
}
gl renderer: try doing outset box shadows Still fall back in cases we can't handle that way.
2017-12-21 17:09:32 +00:00
/* Top side */
gl renderer: Only draw what we have to
2017-12-28 17:00:59 +00:00
if (top_height > 0)
{
x1 = min_x + dx + left_width;
x2 = max_x + dx - right_width;
y1 = min_y + dy;
y2 = min_y + dy + top_height;
tx1 = 0.5f - (SHADOW_EXTRA_SIZE / 2.0f / texture_width);
tx2 = tx1 + (SHADOW_EXTRA_SIZE / texture_width);
ty1 = 1 - (top_height / texture_height);
ty2 = 1;
ops_draw (builder, (GskQuadVertex[GL_N_VERTICES]) {
{ { x1, y1 }, { tx1, ty2 }, },
{ { x1, y2 }, { tx1, ty1 }, },
{ { x2, y1 }, { tx2, ty2 }, },
{ { x2, y2 }, { tx2, ty1 }, },
{ { x1, y2 }, { tx1, ty1 }, },
{ { x2, y1 }, { tx2, ty2 }, },
});
}
gl renderer: try doing outset box shadows Still fall back in cases we can't handle that way.
2017-12-21 17:09:32 +00:00
/* Bottom side */
gl renderer: Only draw what we have to
2017-12-28 17:00:59 +00:00
if (bottom_height > 0)
{
x1 = min_x + dx + left_width;
x2 = max_x + dx - right_width;
y1 = max_y + dy - bottom_height;
y2 = max_y + dy;
tx1 = 0.5f - (SHADOW_EXTRA_SIZE / 2.0f / texture_width);
tx2 = tx1 + (SHADOW_EXTRA_SIZE / texture_width);
ty1 = 0;
ty2 = bottom_height / texture_height;
ops_draw (builder, (GskQuadVertex[GL_N_VERTICES]) {
{ { x1, y1 }, { tx1, ty2 }, },
{ { x1, y2 }, { tx1, ty1 }, },
{ { x2, y1 }, { tx2, ty2 }, },
{ { x2, y2 }, { tx2, ty1 }, },
{ { x1, y2 }, { tx1, ty1 }, },
{ { x2, y1 }, { tx2, ty2 }, },
});
}
gl renderer: draw all outset shadows Instead of falling back to cairo for most of them.
2017-12-28 15:41:32 +00:00
/* Middle */
x1 = min_x + dx + left_width;
x2 = max_x + dx - right_width;
y1 = min_y + dy + top_height;
y2 = max_y + dy - bottom_height;
gl renderer: Only draw what we have to
2017-12-28 17:00:59 +00:00
if (x2 > x1 && y2 > y1)
{
tx1 = (texture_width - SHADOW_EXTRA_SIZE) / 2.0f / texture_width;
tx2 = (texture_width + SHADOW_EXTRA_SIZE) / 2.0f / texture_width;
ty1 = (texture_height - SHADOW_EXTRA_SIZE) / 2.0f / texture_height;
ty2 = (texture_height + SHADOW_EXTRA_SIZE) / 2.0f / texture_height;
ops_draw (builder, (GskQuadVertex[GL_N_VERTICES]) {
{ { x1, y1 }, { tx1, ty2 }, },
{ { x1, y2 }, { tx1, ty1 }, },
{ { x2, y1 }, { tx2, ty2 }, },
{ { x2, y2 }, { tx2, ty1 }, },
{ { x1, y2 }, { tx1, ty1 }, },
{ { x2, y1 }, { tx2, ty2 }, },
});
}
gl renderer: draw all outset shadows Instead of falling back to cairo for most of them.
2017-12-28 15:41:32 +00:00
gl renderer: try doing outset box shadows Still fall back in cases we can't handle that way.
2017-12-21 17:09:32 +00:00
}
gl renderer: Use one function per node-type So a profiler can actually tell me what's slow and not just point at _add_render_ops in all cases.
2017-12-08 12:12:43 +00:00
}
static inline void
render_shadow_node (GskGLRenderer *self,
GskRenderNode *node,
RenderOpBuilder *builder,
const GskQuadVertex *vertex_data)
{
float min_x = node->bounds.origin.x;
float min_y = node->bounds.origin.y;
float max_x = min_x + node->bounds.size.width;
float max_y = min_y + node->bounds.size.height;
GskRenderNode *original_child = gsk_shadow_node_get_child (node);
GskRenderNode *shadow_child = original_child;
gsize n_shadows = gsk_shadow_node_get_n_shadows (node);
guint i;
/* TODO: Implement blurred shadow nodes */;
for (i = 0; i < n_shadows; i ++)
{
const GskShadow *shadow = gsk_shadow_node_peek_shadow (node, i);
if (shadow->radius > 0)
{
gl renderer: Render fallback nodes upside down We stuff both gl-drawn and cairo-drawn textures into the same cache, so we can't really assume that we need to draw any of them flipped or not. Fix this by drawing fallback stuff upside down and then using upside-down vertex data for everything. Fixes #1897
2019-05-18 11:45:19 +00:00
render_fallback_node (self, node, builder);
gl renderer: Use one function per node-type So a profiler can actually tell me what's slow and not just point at _add_render_ops in all cases.
2017-12-08 12:12:43 +00:00
return;
}
}
/* Shadow nodes recolor every pixel of the source texture, but leave the alpha in tact.
* If the child is a color matrix node that doesn't touch the alpha, we can throw that away. */
if (gsk_render_node_get_node_type (shadow_child) == GSK_COLOR_MATRIX_NODE &&
!color_matrix_modifies_alpha (shadow_child))
{
shadow_child = gsk_color_matrix_node_get_child (shadow_child);
}
for (i = 0; i < n_shadows; i ++)
{
const GskShadow *shadow = gsk_shadow_node_peek_shadow (node, i);
gl renderer: Fix shadow nodes if the child is a container
2017-12-09 17:26:29 +00:00
const float dx = shadow->dx;
const float dy = shadow->dy;
Consider all offscreen drawings for the icon cache
2019-06-04 17:28:59 +00:00
TextureRegion region;
gl renderer: Use one function per node-type So a profiler can actually tell me what's slow and not just point at _add_render_ops in all cases.
2017-12-08 12:12:43 +00:00
gboolean is_offscreen;
gl renderer: Fix use of uninitialized values
2017-12-09 13:32:24 +00:00
gl renderer: Use one function per node-type So a profiler can actually tell me what's slow and not just point at _add_render_ops in all cases.
2017-12-08 12:12:43 +00:00
g_assert (shadow->radius <= 0);
if (gsk_render_node_get_node_type (shadow_child) == GSK_TEXT_NODE)
{
gl renderer: Fix shadow node child offset We shouldn't apply the shadow offset when drawing the child offscreen, instead apply it afterwards when we draw it to the current render target.
2018-01-19 14:00:22 +00:00
ops_offset (builder, dx, dy);
gl renderer: Fix shadow nodes if the child is a container
2017-12-09 17:26:29 +00:00
render_text_node (self, shadow_child, builder, &shadow->color, TRUE);
gl renderer: Slightly change ops_offset behavior Add the given delta to the current one instead of replacing it.
2018-04-11 16:09:30 +00:00
ops_offset (builder, - dx, - dy);
gl renderer: Use one function per node-type So a profiler can actually tell me what's slow and not just point at _add_render_ops in all cases.
2017-12-08 12:12:43 +00:00
continue;
}
gl renderer: Skip invisible shadows
2019-05-18 07:11:59 +00:00
if (gdk_rgba_is_clear (&shadow->color))
continue;
gl renderer: care about offset when rendering shadow nodes
2018-12-03 16:49:51 +00:00
min_x = builder->dx + shadow_child->bounds.origin.x;
min_y = builder->dy + shadow_child->bounds.origin.y;
gl renderer: Move geometry calculation further down We don't need it above, so move it to where it belongs.
2018-12-02 08:41:13 +00:00
max_x = min_x + shadow_child->bounds.size.width;
max_y = min_y + shadow_child->bounds.size.height;
gl renderer: Fix shadow node child offset We shouldn't apply the shadow offset when drawing the child offscreen, instead apply it afterwards when we draw it to the current render target.
2018-01-19 14:00:22 +00:00
/* Draw the child offscreen, without the offset. */
gl renderer: Use one function per node-type So a profiler can actually tell me what's slow and not just point at _add_render_ops in all cases.
2017-12-08 12:12:43 +00:00
add_offscreen_ops (self, builder,
gl renderer: Refactor add_offscreen_ops Use a graphene_rect_t for the node bounds instead of 4 floats. This makes it simpler to pass the size in without the offset applied.
2018-12-02 08:05:50 +00:00
&shadow_child->bounds,
Consider all offscreen drawings for the icon cache
2019-06-04 17:28:59 +00:00
shadow_child, &region, &is_offscreen,
gl renderer: Support (not) resetting the opacity for offscreen nodes We usually want to do that, but it's wrong for e.g. crossfade nodes.
2019-01-18 12:06:41 +00:00
RESET_CLIP | RESET_OPACITY);
gl renderer: Use one function per node-type So a profiler can actually tell me what's slow and not just point at _add_render_ops in all cases.
2017-12-08 12:12:43 +00:00
gl renderer: Remove shadow program Drawing shadows is the same task as drawing text in our case and these two shaders have been the same thing for quite a while.
2018-03-15 17:07:35 +00:00
ops_set_program (builder, &self->coloring_program);
gl renderer: Use one function per node-type So a profiler can actually tell me what's slow and not just point at _add_render_ops in all cases.
2017-12-08 12:12:43 +00:00
ops_set_color (builder, &shadow->color);
Consider all offscreen drawings for the icon cache
2019-06-04 17:28:59 +00:00
ops_set_texture (builder, region.texture_id);
gl renderer: Use one function per node-type So a profiler can actually tell me what's slow and not just point at _add_render_ops in all cases.
2017-12-08 12:12:43 +00:00
if (is_offscreen)
{
build: Reintroduce warning flags from autotools Some of the flags got lost in the meson transition or were demoted from error flags to warning flags. This commit reintroduces them. It also includes fixes for the code that had warnings with those flags. The big one being -Wshadow.
2019-01-22 03:30:47 +00:00
const GskQuadVertex offscreen_vertex_data[GL_N_VERTICES] = {
Consider all offscreen drawings for the icon cache
2019-06-04 17:28:59 +00:00
{ { dx + min_x, dy + min_y }, { region.x, region.y2 }, },
{ { dx + min_x, dy + max_y }, { region.x, region.y }, },
{ { dx + max_x, dy + min_y }, { region.x2, region.y2 }, },
gl renderer: Use one function per node-type So a profiler can actually tell me what's slow and not just point at _add_render_ops in all cases.
2017-12-08 12:12:43 +00:00
Consider all offscreen drawings for the icon cache
2019-06-04 17:28:59 +00:00
{ { dx + max_x, dy + max_y }, { region.x2, region.y }, },
{ { dx + min_x, dy + max_y }, { region.x, region.y }, },
{ { dx + max_x, dy + min_y }, { region.x2, region.y2 }, },
gl renderer: Use one function per node-type So a profiler can actually tell me what's slow and not just point at _add_render_ops in all cases.
2017-12-08 12:12:43 +00:00
};
build: Reintroduce warning flags from autotools Some of the flags got lost in the meson transition or were demoted from error flags to warning flags. This commit reintroduces them. It also includes fixes for the code that had warnings with those flags. The big one being -Wshadow.
2019-01-22 03:30:47 +00:00
ops_draw (builder, offscreen_vertex_data);
gl renderer: Use one function per node-type So a profiler can actually tell me what's slow and not just point at _add_render_ops in all cases.
2017-12-08 12:12:43 +00:00
}
else
{
build: Reintroduce warning flags from autotools Some of the flags got lost in the meson transition or were demoted from error flags to warning flags. This commit reintroduces them. It also includes fixes for the code that had warnings with those flags. The big one being -Wshadow.
2019-01-22 03:30:47 +00:00
const GskQuadVertex onscreen_vertex_data[GL_N_VERTICES] = {
Consider all offscreen drawings for the icon cache
2019-06-04 17:28:59 +00:00
{ { dx + min_x, dy + min_y }, { region.x, region.y }, },
{ { dx + min_x, dy + max_y }, { region.x, region.y2 }, },
{ { dx + max_x, dy + min_y }, { region.x2, region.y }, },
gl renderer: Use one function per node-type So a profiler can actually tell me what's slow and not just point at _add_render_ops in all cases.
2017-12-08 12:12:43 +00:00
Consider all offscreen drawings for the icon cache
2019-06-04 17:28:59 +00:00
{ { dx + max_x, dy + max_y }, { region.x2, region.y2 }, },
{ { dx + min_x, dy + max_y }, { region.x, region.y2 }, },
{ { dx + max_x, dy + min_y }, { region.x2, region.y }, },
gl renderer: Use one function per node-type So a profiler can actually tell me what's slow and not just point at _add_render_ops in all cases.
2017-12-08 12:12:43 +00:00
};
build: Reintroduce warning flags from autotools Some of the flags got lost in the meson transition or were demoted from error flags to warning flags. This commit reintroduces them. It also includes fixes for the code that had warnings with those flags. The big one being -Wshadow.
2019-01-22 03:30:47 +00:00
ops_draw (builder, onscreen_vertex_data);
gl renderer: Use one function per node-type So a profiler can actually tell me what's slow and not just point at _add_render_ops in all cases.
2017-12-08 12:12:43 +00:00
}
}
/* Now draw the child normally */
gsk_gl_renderer_add_render_ops (self, original_child, builder);
}
gl renderer: Implement cross fade nodes
2017-12-11 07:22:28 +00:00
static inline void
render_cross_fade_node (GskGLRenderer *self,
GskRenderNode *node,
RenderOpBuilder *builder)
{
gl renderer: Refactor add_offscreen_ops Use a graphene_rect_t for the node bounds instead of 4 floats. This makes it simpler to pass the size in without the offset applied.
2018-12-02 08:05:50 +00:00
const float min_x = builder->dx + node->bounds.origin.x;
const float min_y = builder->dy + node->bounds.origin.y;
gl renderer: Implement cross fade nodes
2017-12-11 07:22:28 +00:00
const float max_x = min_x + node->bounds.size.width;
const float max_y = min_y + node->bounds.size.height;
GskRenderNode *start_node = gsk_cross_fade_node_get_start_child (node);
GskRenderNode *end_node = gsk_cross_fade_node_get_end_child (node);
float progress = gsk_cross_fade_node_get_progress (node);
Consider all offscreen drawings for the icon cache
2019-06-04 17:28:59 +00:00
TextureRegion start_region;
TextureRegion end_region;
gl renderer: Force cross-fade nodes offscreen
2017-12-19 11:45:32 +00:00
gboolean is_offscreen1, is_offscreen2;
gl renderer: Implement cross fade nodes
2017-12-11 07:22:28 +00:00
RenderOp op;
const GskQuadVertex vertex_data[GL_N_VERTICES] = {
{ { min_x, min_y }, { 0, 1 }, },
{ { min_x, max_y }, { 0, 0 }, },
{ { max_x, min_y }, { 1, 1 }, },
{ { max_x, max_y }, { 1, 0 }, },
{ { min_x, max_y }, { 0, 0 }, },
{ { max_x, min_y }, { 1, 1 }, },
};
/* TODO: We create 2 textures here as big as the cross-fade node, but both the
* start and the end node might be a lot smaller than that. */
gl renderer: Refactor add_offscreen_ops Use a graphene_rect_t for the node bounds instead of 4 floats. This makes it simpler to pass the size in without the offset applied.
2018-12-02 08:05:50 +00:00
add_offscreen_ops (self, builder,
&node->bounds,
start_node,
Consider all offscreen drawings for the icon cache
2019-06-04 17:28:59 +00:00
&start_region, &is_offscreen1,
gl renderer: Reset opacity when offscreen-rendering crossfade nodes A pattern emerges...
2019-05-04 08:13:30 +00:00
FORCE_OFFSCREEN | RESET_CLIP | RESET_OPACITY);
gl renderer: Implement cross fade nodes
2017-12-11 07:22:28 +00:00
gl renderer: Refactor add_offscreen_ops Use a graphene_rect_t for the node bounds instead of 4 floats. This makes it simpler to pass the size in without the offset applied.
2018-12-02 08:05:50 +00:00
add_offscreen_ops (self, builder,
&node->bounds,
end_node,
Consider all offscreen drawings for the icon cache
2019-06-04 17:28:59 +00:00
&end_region, &is_offscreen2,
gl renderer: Reset opacity when offscreen-rendering crossfade nodes A pattern emerges...
2019-05-04 08:13:30 +00:00
FORCE_OFFSCREEN | RESET_CLIP | RESET_OPACITY);
gl renderer: Implement cross fade nodes
2017-12-11 07:22:28 +00:00
ops_set_program (builder, &self->cross_fade_program);
op.op = OP_CHANGE_CROSS_FADE;
op.cross_fade.progress = progress;
Consider all offscreen drawings for the icon cache
2019-06-04 17:28:59 +00:00
op.cross_fade.source2 = end_region.texture_id;
gl renderer: Implement cross fade nodes
2017-12-11 07:22:28 +00:00
ops_add (builder, &op);
Consider all offscreen drawings for the icon cache
2019-06-04 17:28:59 +00:00
ops_set_texture (builder, start_region.texture_id);
gl renderer: Implement cross fade nodes
2017-12-11 07:22:28 +00:00
ops_draw (builder, vertex_data);
}
gl renderer: Add simple blend node implementation
2019-04-28 05:46:17 +00:00
static inline void
render_blend_node (GskGLRenderer *self,
GskRenderNode *node,
RenderOpBuilder *builder)
{
GskRenderNode *top_child = gsk_blend_node_get_top_child (node);
GskRenderNode *bottom_child = gsk_blend_node_get_bottom_child (node);
const float min_x = builder->dx + node->bounds.origin.x;
const float min_y = builder->dy + node->bounds.origin.y;
const float max_x = min_x + node->bounds.size.width;
const float max_y = min_y + node->bounds.size.height;
Consider all offscreen drawings for the icon cache
2019-06-04 17:28:59 +00:00
TextureRegion top_region;
TextureRegion bottom_region;
gl renderer: Add simple blend node implementation
2019-04-28 05:46:17 +00:00
gboolean is_offscreen1, is_offscreen2;
RenderOp op;
const GskQuadVertex vertex_data[GL_N_VERTICES] = {
{ { min_x, min_y }, { 0, 1 }, },
{ { min_x, max_y }, { 0, 0 }, },
{ { max_x, min_y }, { 1, 1 }, },
{ { max_x, max_y }, { 1, 0 }, },
{ { min_x, max_y }, { 0, 0 }, },
{ { max_x, min_y }, { 1, 1 }, },
};
/* TODO: We create 2 textures here as big as the blend node, but both the
* start and the end node might be a lot smaller than that. */
add_offscreen_ops (self, builder,
&node->bounds,
bottom_child,
Consider all offscreen drawings for the icon cache
2019-06-04 17:28:59 +00:00
&bottom_region, &is_offscreen1,
gl renderer: Add simple blend node implementation
2019-04-28 05:46:17 +00:00
FORCE_OFFSCREEN | RESET_CLIP);
add_offscreen_ops (self, builder,
&node->bounds,
top_child,
Consider all offscreen drawings for the icon cache
2019-06-04 17:28:59 +00:00
&top_region, &is_offscreen2,
gl renderer: Add simple blend node implementation
2019-04-28 05:46:17 +00:00
FORCE_OFFSCREEN | RESET_CLIP);
ops_set_program (builder, &self->blend_program);
Consider all offscreen drawings for the icon cache
2019-06-04 17:28:59 +00:00
ops_set_texture (builder, bottom_region.texture_id);
gl renderer: Add simple blend node implementation
2019-04-28 05:46:17 +00:00
op.op = OP_CHANGE_BLEND;
Consider all offscreen drawings for the icon cache
2019-06-04 17:28:59 +00:00
op.blend.source2 = top_region.texture_id;
gl renderer: Add simple blend node implementation
2019-04-28 05:46:17 +00:00
op.blend.mode = gsk_blend_node_get_blend_mode (node);
ops_add (builder, &op);
ops_draw (builder, vertex_data);
}
gl renderer: Use one function per op type to apply data
2017-12-16 09:02:03 +00:00
static inline void
apply_viewport_op (const Program *program,
const RenderOp *op)
{
OP_PRINT (" -> New Viewport: %f, %f, %f, %f", op->viewport.origin.x, op->viewport.origin.y, op->viewport.size.width, op->viewport.size.height);
glUniform4f (program->viewport_location,
op->viewport.origin.x, op->viewport.origin.y,
op->viewport.size.width, op->viewport.size.height);
glViewport (0, 0, op->viewport.size.width, op->viewport.size.height);
}
static inline void
apply_modelview_op (const Program *program,
const RenderOp *op)
{
float mat[16];
OP_PRINT (" -> Modelview");
graphene_matrix_to_float (&op->modelview, mat);
glUniformMatrix4fv (program->modelview_location, 1, GL_FALSE, mat);
}
static inline void
apply_projection_op (const Program *program,
const RenderOp *op)
{
float mat[16];
OP_PRINT (" -> Projection");
graphene_matrix_to_float (&op->projection, mat);
glUniformMatrix4fv (program->projection_location, 1, GL_FALSE, mat);
}
static inline void
apply_program_op (const Program *program,
const RenderOp *op)
{
OP_PRINT (" -> Program: %d", op->program->index);
glUseProgram (op->program->id);
}
static inline void
apply_render_target_op (GskGLRenderer *self,
const Program *program,
const RenderOp *op)
{
OP_PRINT (" -> Render Target: %d", op->render_target_id);
glBindFramebuffer (GL_FRAMEBUFFER, op->render_target_id);
if (op->render_target_id != 0)
glDisable (GL_SCISSOR_TEST);
else
gsk_gl_renderer_setup_render_mode (self); /* Reset glScissor etc. */
}
static inline void
apply_color_op (const Program *program,
const RenderOp *op)
{
OP_PRINT (" -> Color: (%f, %f, %f, %f)", op->color.red, op->color.green, op->color.blue, op->color.alpha);
glUniform4f (program->color.color_location,
op->color.red, op->color.green, op->color.blue, op->color.alpha);
}
static inline void
apply_opacity_op (const Program *program,
const RenderOp *op)
{
OP_PRINT (" -> Opacity %f", op->opacity);
glUniform1f (program->alpha_location, op->opacity);
}
static inline void
apply_source_texture_op (const Program *program,
const RenderOp *op)
{
g_assert(op->texture_id != 0);
OP_PRINT (" -> New texture: %d", op->texture_id);
/* Use texture unit 0 for the source */
glUniform1i (program->source_location, 0);
glActiveTexture (GL_TEXTURE0);
glBindTexture (GL_TEXTURE_2D, op->texture_id);
}
static inline void
apply_color_matrix_op (const Program *program,
const RenderOp *op)
{
float mat[16];
float vec[4];
OP_PRINT (" -> Color Matrix");
graphene_matrix_to_float (&op->color_matrix.matrix, mat);
glUniformMatrix4fv (program->color_matrix.color_matrix_location, 1, GL_FALSE, mat);
graphene_vec4_to_float (&op->color_matrix.offset, vec);
glUniform4fv (program->color_matrix.color_offset_location, 1, vec);
}
static inline void
apply_clip_op (const Program *program,
const RenderOp *op)
{
OP_PRINT (" -> Clip (%f, %f, %f, %f) (%f, %f, %f, %f), (%f, %f, %f, %f)",
op->clip.bounds.origin.x, op->clip.bounds.origin.y,
op->clip.bounds.size.width, op->clip.bounds.size.height,
op->clip.corner[0].width,
op->clip.corner[1].width,
op->clip.corner[2].width,
op->clip.corner[3].width,
op->clip.corner[0].height,
op->clip.corner[1].height,
op->clip.corner[2].height,
op->clip.corner[3].height);
glUniform4f (program->clip_location,
op->clip.bounds.origin.x, op->clip.bounds.origin.y,
op->clip.bounds.size.width, op->clip.bounds.size.height);
glUniform4f (program->clip_corner_widths_location,
op->clip.corner[0].width,
op->clip.corner[1].width,
op->clip.corner[2].width,
op->clip.corner[3].width);
glUniform4f (program->clip_corner_heights_location,
op->clip.corner[0].height,
op->clip.corner[1].height,
op->clip.corner[2].height,
op->clip.corner[3].height);
}
static inline void
apply_inset_shadow_op (const Program *program,
const RenderOp *op)
{
OP_PRINT (" -> inset shadow. Color: (%f, %f, %f, %f), Offset: (%f, %f), Spread: %f, Outline: (%f, %f, %f, %f) Corner widths: (%f, %f, %f, %f), Corner Heights: (%f, %f, %f, %f)",
op->inset_shadow.color[0],
op->inset_shadow.color[1],
op->inset_shadow.color[2],
op->inset_shadow.color[3],
op->inset_shadow.offset[0],
op->inset_shadow.offset[1],
op->inset_shadow.spread,
op->inset_shadow.outline[0],
op->inset_shadow.outline[1],
op->inset_shadow.outline[2],
op->inset_shadow.outline[3],
op->inset_shadow.corner_widths[0],
op->inset_shadow.corner_widths[1],
op->inset_shadow.corner_widths[2],
op->inset_shadow.corner_widths[3],
op->inset_shadow.corner_heights[0],
op->inset_shadow.corner_heights[1],
op->inset_shadow.corner_heights[2],
op->inset_shadow.corner_heights[3]);
glUniform4fv (program->inset_shadow.color_location, 1, op->inset_shadow.color);
glUniform2fv (program->inset_shadow.offset_location, 1, op->inset_shadow.offset);
glUniform1f (program->inset_shadow.spread_location, op->inset_shadow.spread);
glUniform4fv (program->inset_shadow.outline_location, 1, op->inset_shadow.outline);
glUniform4fv (program->inset_shadow.corner_widths_location, 1, op->inset_shadow.corner_widths);
glUniform4fv (program->inset_shadow.corner_heights_location, 1, op->inset_shadow.corner_heights);
}
gl renderer: Render unblurred outset shadows differently We don't need to draw anything to a texure for those.
2018-01-15 09:55:40 +00:00
static inline void
apply_unblurred_outset_shadow_op (const Program *program,
const RenderOp *op)
{
OP_PRINT (" -> unblurred outset shadow");
glUniform4fv (program->unblurred_outset_shadow.color_location, 1, op->unblurred_outset_shadow.color);
glUniform2fv (program->unblurred_outset_shadow.offset_location, 1, op->unblurred_outset_shadow.offset);
glUniform1f (program->unblurred_outset_shadow.spread_location, op->unblurred_outset_shadow.spread);
glUniform4fv (program->unblurred_outset_shadow.outline_location, 1, op->unblurred_outset_shadow.outline);
glUniform4fv (program->unblurred_outset_shadow.corner_widths_location, 1,
op->unblurred_outset_shadow.corner_widths);
glUniform4fv (program->unblurred_outset_shadow.corner_heights_location, 1,
op->unblurred_outset_shadow.corner_heights);
}
gl renderer: Use one function per op type to apply data
2017-12-16 09:02:03 +00:00
static inline void
apply_outset_shadow_op (const Program *program,
const RenderOp *op)
{
OP_PRINT (" -> outset shadow");
glUniform4fv (program->outset_shadow.outline_location, 1, op->outset_shadow.outline);
glUniform4fv (program->outset_shadow.corner_widths_location, 1, op->outset_shadow.corner_widths);
glUniform4fv (program->outset_shadow.corner_heights_location, 1, op->outset_shadow.corner_heights);
}
static inline void
apply_linear_gradient_op (const Program *program,
const RenderOp *op)
{
OP_PRINT (" -> Linear gradient");
glUniform1i (program->linear_gradient.num_color_stops_location,
op->linear_gradient.n_color_stops);
glUniform4fv (program->linear_gradient.color_stops_location,
op->linear_gradient.n_color_stops,
op->linear_gradient.color_stops);
glUniform1fv (program->linear_gradient.color_offsets_location,
op->linear_gradient.n_color_stops,
op->linear_gradient.color_offsets);
glUniform2f (program->linear_gradient.start_point_location,
op->linear_gradient.start_point.x, op->linear_gradient.start_point.y);
glUniform2f (program->linear_gradient.end_point_location,
op->linear_gradient.end_point.x, op->linear_gradient.end_point.y);
}
static inline void
apply_border_op (const Program *program,
const RenderOp *op)
{
gl renderer: Fix clipped borders Stop abusing the clip rect for borders.
2018-03-15 16:27:19 +00:00
const GskRoundedRect *o = &op->border.outline;
float outline[4];
float widths[4];
float heights[4];
int i;
gl renderer: Track border width state separately
2018-12-05 09:44:11 +00:00
OP_PRINT (" -> Border Outline");
gl renderer: Fix clipped borders Stop abusing the clip rect for borders.
2018-03-15 16:27:19 +00:00
outline[0] = o->bounds.origin.x;
outline[1] = o->bounds.origin.y;
outline[2] = o->bounds.size.width;
outline[3] = o->bounds.size.height;
for (i = 0; i < 4; i ++)
{
widths[i] = o->corner[i].width;
heights[i] = o->corner[i].height;
}
glUniform4fv (program->border.outline_location, 1, outline);
glUniform4fv (program->border.corner_widths_location, 1, widths);
glUniform4fv (program->border.corner_heights_location, 1, heights);
gl renderer: Use one function per op type to apply data
2017-12-16 09:02:03 +00:00
}
gl renderer: Track border width state separately
2018-12-05 09:44:11 +00:00
static inline void
apply_border_width_op (const Program *program,
const RenderOp *op)
{
OP_PRINT (" -> Border width (%f, %f, %f, %f)",
op->border.widths[0], op->border.widths[1], op->border.widths[2], op->border.widths[3]);
glUniform4fv (program->border.widths_location, 1, op->border.widths);
}
gl renderer: Use one function per op type to apply data
2017-12-16 09:02:03 +00:00
static inline void
apply_border_color_op (const Program *program,
const RenderOp *op)
{
OP_PRINT (" -> Border color (%f, %f, %f, %f)",
op->border.color[0], op->border.color[1], op->border.color[2], op->border.color[3]);
glUniform4fv (program->border.color_location, 1, op->border.color);
}
static inline void
apply_blur_op (const Program *program,
const RenderOp *op)
{
OP_PRINT (" -> Blur");
glUniform1f (program->blur.blur_radius_location, op->blur.radius);
glUniform2f (program->blur.blur_size_location, op->blur.size.width, op->blur.size.height);
gl renderer: draw all outset shadows Instead of falling back to cairo for most of them.
2017-12-28 15:41:32 +00:00
/*glUniform2f (program->blur.dir_location, op->blur.dir[0], op->blur.dir[1]);*/
gl renderer: Use one function per op type to apply data
2017-12-16 09:02:03 +00:00
}
static inline void
apply_cross_fade_op (const Program *program,
const RenderOp *op)
{
/* End texture id */
glUniform1i (program->cross_fade.source2_location, 1);
glActiveTexture (GL_TEXTURE0 + 1);
glBindTexture (GL_TEXTURE_2D, op->cross_fade.source2);
/* progress */
glUniform1f (program->cross_fade.progress_location, op->cross_fade.progress);
}
gl renderer: Add simple blend node implementation
2019-04-28 05:46:17 +00:00
static inline void
apply_blend_op (const Program *program,
const RenderOp *op)
{
/* End texture id */
glUniform1i (program->blend.source2_location, 1);
glActiveTexture (GL_TEXTURE0 + 1);
glBindTexture (GL_TEXTURE_2D, op->blend.source2);
/* progress */
glUniform1i (program->blend.mode_location, op->blend.mode);
}
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_gl_renderer_dispose (GObject *gobject)
{
GskGLRenderer *self = GSK_GL_RENDERER (gobject);
gl renderer: Rework once more Last time, I swear.
2017-11-22 10:32:23 +00:00
g_clear_pointer (&self->render_ops, g_array_unref);
gl renderer: Properly clean up program state transforms
2019-07-06 11:38:55 +00:00
ops_free (&self->op_builder);
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_gl_renderer_parent_class)->dispose (gobject);
}
gsk: Rework how GLSL shaders are built The GL renderer should build the GLSL shaders using GskShaderBuilder. This allows us to separate the common parts into separate files, and assemble them as necessary, instead of shipping one big shader per type of GL API (GL3, GL legacy, and GLES).
2016-07-03 20:12:22 +00:00
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_gl_renderer_create_programs (GskGLRenderer *self,
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: Rework how GLSL shaders are built The GL renderer should build the GLSL shaders using GskShaderBuilder. This allows us to separate the common parts into separate files, and assemble them as necessary, instead of shipping one big shader per type of GL API (GL3, GL legacy, and GLES).
2016-07-03 20:12:22 +00:00
GskShaderBuilder *builder;
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 *shader_error = NULL;
gl renderer: Rework program creation Make sure all uniform names have to match between the shader names and the _location integers we save in every Program struct.
2017-11-30 17:47:55 +00:00
int i;
gl renderer: Sprinkle some const around
2018-01-08 20:46:16 +00:00
static const struct {
gl renderer: Rework program creation Make sure all uniform names have to match between the shader names and the _location integers we save in every Program struct.
2017-11-30 17:47:55 +00:00
const char *name;
const char *fs;
} program_definitions[] = {
gl renderer: Only compile the vertex shader once All our programs use the same vertex shader, so don't compile it over and over again. This improves startup times by at least 0.001%, I swear.
2019-01-06 05:55:31 +00:00
{ "blit", "blit.fs.glsl" },
{ "color", "color.fs.glsl" },
{ "coloring", "coloring.fs.glsl" },
{ "color matrix", "color_matrix.fs.glsl" },
{ "linear gradient", "linear_gradient.fs.glsl" },
{ "blur", "blur.fs.glsl" },
{ "inset shadow", "inset_shadow.fs.glsl" },
{ "outset shadow", "outset_shadow.fs.glsl" },
{ "unblurred outset shadow", "unblurred_outset_shadow.fs.glsl" },
{ "border", "border.fs.glsl" },
{ "cross fade", "cross_fade.fs.glsl" },
gl renderer: Add simple blend node implementation
2019-04-28 05:46:17 +00:00
{ "blend", "blend.fs.glsl" },
gl renderer: Rework program creation Make sure all uniform names have to match between the shader names and the _location integers we save in every Program struct.
2017-11-30 17:47:55 +00:00
};
gsk: Don't store the uniform and attribute location twice We should keep the ShaderBuilder around and use it to query the various uniform and attribute locations when needed, instead of storing those offsets into the Renderer instance, and copying them. This allows a bit more flexibility, once we have more than one program built into the renderer.
2016-07-03 21:54:30 +00:00
gsk: Rework how GLSL shaders are built The GL renderer should build the GLSL shaders using GskShaderBuilder. This allows us to separate the common parts into separate files, and assemble them as necessary, instead of shipping one big shader per type of GL API (GL3, GL legacy, and GLES).
2016-07-03 20:12:22 +00:00
builder = gsk_shader_builder_new ();
gsk_shader_builder_set_resource_base_path (builder, "/org/gtk/libgsk/glsl");
gsk: Bind GL context to the GL profiler Similarly to how we bind it to the GL driver object used by the GSK GL renderer.
2016-07-27 10:34:20 +00:00
if (gdk_gl_context_get_use_es (self->gl_context))
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 how GLSL shaders are built The GL renderer should build the GLSL shaders using GskShaderBuilder. This allows us to separate the common parts into separate files, and assemble them as necessary, instead of shipping one big shader per type of GL API (GL3, GL legacy, and GLES).
2016-07-03 20:12:22 +00:00
gsk_shader_builder_set_version (builder, SHADER_VERSION_GLES);
gsk: Consolidate program creation and storage We should use ShaderBuilder to create and store programs for the GL renderer. This allows us to simplify the creation of programs (by moving the compilation phase into the ShaderBuilder::create_program() method), and move towards the ability to create multiple programs and just keep a reference to the program id.
2016-07-04 12:46:22 +00:00
gsk_shader_builder_set_vertex_preamble (builder, "es2_common.vs.glsl");
gsk_shader_builder_set_fragment_preamble (builder, "es2_common.fs.glsl");
gsk: Rework how GLSL shaders are built The GL renderer should build the GLSL shaders using GskShaderBuilder. This allows us to separate the common parts into separate files, and assemble them as necessary, instead of shipping one big shader per type of GL API (GL3, GL legacy, and GLES).
2016-07-03 20:12:22 +00:00
gsk_shader_builder_add_define (builder, "GSK_GLES", "1");
}
gsk: Bind GL context to the GL profiler Similarly to how we bind it to the GL driver object used by the GSK GL renderer.
2016-07-27 10:34:20 +00:00
else if (gdk_gl_context_is_legacy (self->gl_context))
gsk: Rework how GLSL shaders are built The GL renderer should build the GLSL shaders using GskShaderBuilder. This allows us to separate the common parts into separate files, and assemble them as necessary, instead of shipping one big shader per type of GL API (GL3, GL legacy, and GLES).
2016-07-03 20:12:22 +00:00
{
gsk: Use the appropriate GLSL version The GLSL versions are: OpenGL 2.1: #version 110 OpenGL 3.0: #version 130 OpenGL 3.2: #version 150 OpenGLES 2.0: #version 100 OpenGLES 3.0: #version 300 es So we need to check the version of the GdkGLContext if we want use the appropriate version, especially for legacy OpenGL contexts, which can be both 3.x and 2.x.
2016-11-01 15:00:31 +00:00
int maj, min;
gdk_gl_context_get_version (self->gl_context, &maj, &min);
if (maj == 3)
gsk_shader_builder_set_version (builder, SHADER_VERSION_GL3_LEGACY);
else
gsk_shader_builder_set_version (builder, SHADER_VERSION_GL2_LEGACY);
gsk: Consolidate program creation and storage We should use ShaderBuilder to create and store programs for the GL renderer. This allows us to simplify the creation of programs (by moving the compilation phase into the ShaderBuilder::create_program() method), and move towards the ability to create multiple programs and just keep a reference to the program id.
2016-07-04 12:46:22 +00:00
gsk_shader_builder_set_vertex_preamble (builder, "gl_common.vs.glsl");
gsk_shader_builder_set_fragment_preamble (builder, "gl_common.fs.glsl");
gsk: Rework how GLSL shaders are built The GL renderer should build the GLSL shaders using GskShaderBuilder. This allows us to separate the common parts into separate files, and assemble them as necessary, instead of shipping one big shader per type of GL API (GL3, GL legacy, and GLES).
2016-07-03 20:12:22 +00:00
gsk_shader_builder_add_define (builder, "GSK_LEGACY", "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
}
gsk: Rework how GLSL shaders are built The GL renderer should build the GLSL shaders using GskShaderBuilder. This allows us to separate the common parts into separate files, and assemble them as necessary, instead of shipping one big shader per type of GL API (GL3, GL legacy, and GLES).
2016-07-03 20:12:22 +00:00
else
{
gsk_shader_builder_set_version (builder, SHADER_VERSION_GL3);
gsk: Consolidate program creation and storage We should use ShaderBuilder to create and store programs for the GL renderer. This allows us to simplify the creation of programs (by moving the compilation phase into the ShaderBuilder::create_program() method), and move towards the ability to create multiple programs and just keep a reference to the program id.
2016-07-04 12:46:22 +00:00
gsk_shader_builder_set_vertex_preamble (builder, "gl3_common.vs.glsl");
gsk_shader_builder_set_fragment_preamble (builder, "gl3_common.fs.glsl");
gsk: Rework how GLSL shaders are built The GL renderer should build the GLSL shaders using GskShaderBuilder. This allows us to separate the common parts into separate files, and assemble them as necessary, instead of shipping one big shader per type of GL API (GL3, GL legacy, and GLES).
2016-07-03 20:12:22 +00:00
gsk_shader_builder_add_define (builder, "GSK_GL3", "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
gsk: Rework how GLSL shaders are built The GL renderer should build the GLSL shaders using GskShaderBuilder. This allows us to separate the common parts into separate files, and assemble them as necessary, instead of shipping one big shader per type of GL API (GL3, GL legacy, and GLES).
2016-07-03 20:12:22 +00:00
#ifdef G_ENABLE_DEBUG
gsk: Reorganize env vars Get rid of GSK_RENDERING_MODE and add the flags to GSK_DEBUG, following the same pattern we use in gdk now.
2018-01-14 20:11:33 +00:00
if (GSK_RENDERER_DEBUG_CHECK (GSK_RENDERER (self), SHADERS))
gsk: Rework how GLSL shaders are built The GL renderer should build the GLSL shaders using GskShaderBuilder. This allows us to separate the common parts into separate files, and assemble them as necessary, instead of shipping one big shader per type of GL API (GL3, GL legacy, and GLES).
2016-07-03 20:12:22 +00:00
gsk_shader_builder_add_define (builder, "GSK_DEBUG", "1");
#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
gl renderer: Only compile the vertex shader once All our programs use the same vertex shader, so don't compile it over and over again. This improves startup times by at least 0.001%, I swear.
2019-01-06 05:55:31 +00:00
gsk_shader_builder_set_common_vertex_shader (builder, "blit.vs.glsl",
&shader_error);
g_assert_no_error (shader_error);
gl renderer: Rework program creation Make sure all uniform names have to match between the shader names and the _location integers we save in every Program struct.
2017-11-30 17:47:55 +00:00
for (i = 0; i < GL_N_PROGRAMS; i ++)
gl renderer: Implement blur nodes
2017-11-25 07:56:50 +00:00
{
gl renderer: Rework program creation Make sure all uniform names have to match between the shader names and the _location integers we save in every Program struct.
2017-11-30 17:47:55 +00:00
Program *prog = &self->programs[i];
prog->index = i;
prog->id = gsk_shader_builder_create_program (builder,
program_definitions[i].fs,
&shader_error);
if (shader_error != NULL)
{
g_propagate_prefixed_error (error, shader_error,
"Unable to create '%s' program (from %s and %s):\n",
program_definitions[i].name,
gl renderer: Only compile the vertex shader once All our programs use the same vertex shader, so don't compile it over and over again. This improves startup times by at least 0.001%, I swear.
2019-01-06 05:55:31 +00:00
"blit.vs.glsl",
gl renderer: Rework program creation Make sure all uniform names have to match between the shader names and the _location integers we save in every Program struct.
2017-11-30 17:47:55 +00:00
program_definitions[i].fs);
g_object_unref (builder);
return FALSE;
}
INIT_COMMON_UNIFORM_LOCATION (prog, alpha);
INIT_COMMON_UNIFORM_LOCATION (prog, source);
INIT_COMMON_UNIFORM_LOCATION (prog, clip);
INIT_COMMON_UNIFORM_LOCATION (prog, clip_corner_widths);
INIT_COMMON_UNIFORM_LOCATION (prog, clip_corner_heights);
INIT_COMMON_UNIFORM_LOCATION (prog, viewport);
INIT_COMMON_UNIFORM_LOCATION (prog, projection);
INIT_COMMON_UNIFORM_LOCATION (prog, modelview);
gl renderer: Implement unblurred inset shadows
2017-11-30 15:48:03 +00:00
}
gl renderer: Rework program creation Make sure all uniform names have to match between the shader names and the _location integers we save in every Program struct.
2017-11-30 17:47:55 +00:00
/* color */
gl renderer: Rename a macro
2017-12-01 12:56:56 +00:00
INIT_PROGRAM_UNIFORM_LOCATION (color, color);
gl renderer: Rework program creation Make sure all uniform names have to match between the shader names and the _location integers we save in every Program struct.
2017-11-30 17:47:55 +00:00
/* coloring */
gl renderer: Rename a macro
2017-12-01 12:56:56 +00:00
INIT_PROGRAM_UNIFORM_LOCATION (coloring, color);
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
gl renderer: Rework program creation Make sure all uniform names have to match between the shader names and the _location integers we save in every Program struct.
2017-11-30 17:47:55 +00:00
/* color matrix */
gl renderer: Rename a macro
2017-12-01 12:56:56 +00:00
INIT_PROGRAM_UNIFORM_LOCATION (color_matrix, color_matrix);
INIT_PROGRAM_UNIFORM_LOCATION (color_matrix, color_offset);
gl renderer: Rework program creation Make sure all uniform names have to match between the shader names and the _location integers we save in every Program struct.
2017-11-30 17:47:55 +00:00
/* linear gradient */
gl renderer: Rename a macro
2017-12-01 12:56:56 +00:00
INIT_PROGRAM_UNIFORM_LOCATION (linear_gradient, color_stops);
INIT_PROGRAM_UNIFORM_LOCATION (linear_gradient, color_offsets);
INIT_PROGRAM_UNIFORM_LOCATION (linear_gradient, num_color_stops);
INIT_PROGRAM_UNIFORM_LOCATION (linear_gradient, start_point);
INIT_PROGRAM_UNIFORM_LOCATION (linear_gradient, end_point);
gl renderer: Rework program creation Make sure all uniform names have to match between the shader names and the _location integers we save in every Program struct.
2017-11-30 17:47:55 +00:00
/* blur */
gl renderer: Rename a macro
2017-12-01 12:56:56 +00:00
INIT_PROGRAM_UNIFORM_LOCATION (blur, blur_radius);
INIT_PROGRAM_UNIFORM_LOCATION (blur, blur_size);
gl renderer: draw all outset shadows Instead of falling back to cairo for most of them.
2017-12-28 15:41:32 +00:00
/*INIT_PROGRAM_UNIFORM_LOCATION (blur, dir);*/
gl renderer: Rework program creation Make sure all uniform names have to match between the shader names and the _location integers we save in every Program struct.
2017-11-30 17:47:55 +00:00
/* inset shadow */
gl renderer: Rename a macro
2017-12-01 12:56:56 +00:00
INIT_PROGRAM_UNIFORM_LOCATION (inset_shadow, color);
INIT_PROGRAM_UNIFORM_LOCATION (inset_shadow, spread);
INIT_PROGRAM_UNIFORM_LOCATION (inset_shadow, offset);
INIT_PROGRAM_UNIFORM_LOCATION (inset_shadow, outline);
INIT_PROGRAM_UNIFORM_LOCATION (inset_shadow, corner_widths);
INIT_PROGRAM_UNIFORM_LOCATION (inset_shadow, corner_heights);
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
gl renderer: Implement unblurred outset shadows
2017-12-01 07:30:11 +00:00
/* outset shadow */
gl renderer: Rename a macro
2017-12-01 12:56:56 +00:00
INIT_PROGRAM_UNIFORM_LOCATION (outset_shadow, outline);
INIT_PROGRAM_UNIFORM_LOCATION (outset_shadow, corner_widths);
INIT_PROGRAM_UNIFORM_LOCATION (outset_shadow, corner_heights);
gl renderer: Implement unblurred outset shadows
2017-12-01 07:30:11 +00:00
gl renderer: Render unblurred outset shadows differently We don't need to draw anything to a texure for those.
2018-01-15 09:55:40 +00:00
/* unblurred outset shadow */
INIT_PROGRAM_UNIFORM_LOCATION (unblurred_outset_shadow, color);
INIT_PROGRAM_UNIFORM_LOCATION (unblurred_outset_shadow, spread);
INIT_PROGRAM_UNIFORM_LOCATION (unblurred_outset_shadow, offset);
INIT_PROGRAM_UNIFORM_LOCATION (unblurred_outset_shadow, outline);
INIT_PROGRAM_UNIFORM_LOCATION (unblurred_outset_shadow, corner_widths);
INIT_PROGRAM_UNIFORM_LOCATION (unblurred_outset_shadow, corner_heights);
gl renderer: Implement simple border nodes
2017-12-01 10:55:10 +00:00
/* border */
gl renderer: Rename a macro
2017-12-01 12:56:56 +00:00
INIT_PROGRAM_UNIFORM_LOCATION (border, color);
INIT_PROGRAM_UNIFORM_LOCATION (border, widths);
gl renderer: Fix clipped borders Stop abusing the clip rect for borders.
2018-03-15 16:27:19 +00:00
INIT_PROGRAM_UNIFORM_LOCATION (border, outline);
INIT_PROGRAM_UNIFORM_LOCATION (border, corner_widths);
INIT_PROGRAM_UNIFORM_LOCATION (border, corner_heights);
gl renderer: Implement simple border nodes
2017-12-01 10:55:10 +00:00
gl renderer: Implement cross fade nodes
2017-12-11 07:22:28 +00:00
/* cross fade */
INIT_PROGRAM_UNIFORM_LOCATION (cross_fade, progress);
INIT_PROGRAM_UNIFORM_LOCATION (cross_fade, source2);
gl renderer: Add simple blend node implementation
2019-04-28 05:46:17 +00:00
/* blend */
INIT_PROGRAM_UNIFORM_LOCATION (blend, source2);
INIT_PROGRAM_UNIFORM_LOCATION (blend, mode);
Rework the GL renderer
2017-11-03 12:09:02 +00:00
g_object_unref (builder);
gl renderer: Rework program creation Make sure all uniform names have to match between the shader names and the _location integers we save in every Program struct.
2017-11-30 17:47:55 +00:00
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
}
Share glyph and icon caches Use the same texture atlases to back both the glyph and icon caches, and unify their sizes and management. Store big glyphs in separate textures, so all atlases have the same size. Tweak some of the eviction parameters. We share the caches across all GL contexts on a display, unless the GSK_NO_SHARED_CACHES env var is set.
2019-06-04 21:27:09 +00:00
static GskGLTextureAtlases *
get_texture_atlases_for_display (GdkDisplay *display)
{
GskGLTextureAtlases *atlases;
if (g_getenv ("GSK_NO_SHARED_CACHES"))
return gsk_gl_texture_atlases_new ();
atlases = (GskGLTextureAtlases*)g_object_get_data (G_OBJECT (display), "gsk-gl-texture-atlases");
if (atlases == NULL)
{
atlases = gsk_gl_texture_atlases_new ();
g_object_set_data_full (G_OBJECT (display), "gsk-gl-texture-atlases",
Fix a refcounting mishap We were missing a ref, causing caches to go missing when a window is opened twice.
2019-06-05 02:49:07 +00:00
atlases,
Share glyph and icon caches Use the same texture atlases to back both the glyph and icon caches, and unify their sizes and management. Store big glyphs in separate textures, so all atlases have the same size. Tweak some of the eviction parameters. We share the caches across all GL contexts on a display, unless the GSK_NO_SHARED_CACHES env var is set.
2019-06-04 21:27:09 +00:00
(GDestroyNotify) gsk_gl_texture_atlases_unref);
}
Fix a refcounting mishap We were missing a ref, causing caches to go missing when a window is opened twice.
2019-06-05 02:49:07 +00:00
return gsk_gl_texture_atlases_ref (atlases);
Share glyph and icon caches Use the same texture atlases to back both the glyph and icon caches, and unify their sizes and management. Store big glyphs in separate textures, so all atlases have the same size. Tweak some of the eviction parameters. We share the caches across all GL contexts on a display, unless the GSK_NO_SHARED_CACHES env var is set.
2019-06-04 21:27:09 +00:00
}
static GskGLGlyphCache *
get_glyph_cache_for_display (GdkDisplay *display,
GskGLTextureAtlases *atlases)
{
GskGLGlyphCache *glyph_cache;
if (g_getenv ("GSK_NO_SHARED_CACHES"))
return gsk_gl_glyph_cache_new (display, atlases);
glyph_cache = (GskGLGlyphCache*)g_object_get_data (G_OBJECT (display), "gsk-gl-glyph-cache");
if (glyph_cache == NULL)
{
glyph_cache = gsk_gl_glyph_cache_new (display, atlases);
g_object_set_data_full (G_OBJECT (display), "gsk-gl-glyph-cache",
Fix a refcounting mishap We were missing a ref, causing caches to go missing when a window is opened twice.
2019-06-05 02:49:07 +00:00
glyph_cache,
Share glyph and icon caches Use the same texture atlases to back both the glyph and icon caches, and unify their sizes and management. Store big glyphs in separate textures, so all atlases have the same size. Tweak some of the eviction parameters. We share the caches across all GL contexts on a display, unless the GSK_NO_SHARED_CACHES env var is set.
2019-06-04 21:27:09 +00:00
(GDestroyNotify) gsk_gl_glyph_cache_unref);
}
Fix a refcounting mishap We were missing a ref, causing caches to go missing when a window is opened twice.
2019-06-05 02:49:07 +00:00
return gsk_gl_glyph_cache_ref (glyph_cache);
Share glyph and icon caches Use the same texture atlases to back both the glyph and icon caches, and unify their sizes and management. Store big glyphs in separate textures, so all atlases have the same size. Tweak some of the eviction parameters. We share the caches across all GL contexts on a display, unless the GSK_NO_SHARED_CACHES env var is set.
2019-06-04 21:27:09 +00:00
}
static GskGLIconCache *
get_icon_cache_for_display (GdkDisplay *display,
GskGLTextureAtlases *atlases)
{
GskGLIconCache *icon_cache;
if (g_getenv ("GSK_NO_SHARED_CACHES"))
return gsk_gl_icon_cache_new (display, atlases);
icon_cache = (GskGLIconCache*)g_object_get_data (G_OBJECT (display), "gsk-gl-icon-cache");
if (icon_cache == NULL)
{
icon_cache = gsk_gl_icon_cache_new (display, atlases);
g_object_set_data_full (G_OBJECT (display), "gsk-gl-icon-cache",
Fix a refcounting mishap We were missing a ref, causing caches to go missing when a window is opened twice.
2019-06-05 02:49:07 +00:00
icon_cache,
Share glyph and icon caches Use the same texture atlases to back both the glyph and icon caches, and unify their sizes and management. Store big glyphs in separate textures, so all atlases have the same size. Tweak some of the eviction parameters. We share the caches across all GL contexts on a display, unless the GSK_NO_SHARED_CACHES env var is set.
2019-06-04 21:27:09 +00:00
(GDestroyNotify) gsk_gl_icon_cache_unref);
}
Fix a refcounting mishap We were missing a ref, causing caches to go missing when a window is opened twice.
2019-06-05 02:49:07 +00:00
return gsk_gl_icon_cache_ref (icon_cache);
Share glyph and icon caches Use the same texture atlases to back both the glyph and icon caches, and unify their sizes and management. Store big glyphs in separate textures, so all atlases have the same size. Tweak some of the eviction parameters. We share the caches across all GL contexts on a display, unless the GSK_NO_SHARED_CACHES env var is set.
2019-06-04 21:27:09 +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
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_gl_renderer_realize (GskRenderer *renderer,
gl renderer: Rename everything called window to surface
2018-03-26 19:13:52 +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
{
GskGLRenderer *self = GSK_GL_RENDERER (renderer);
/* If we didn't get a GdkGLContext before realization, try creating
* one now, for our exclusive use.
*/
gsk: Bind GL context to the GL profiler Similarly to how we bind it to the GL driver object used by the GSK GL renderer.
2016-07-27 10:34:20 +00:00
if (self->gl_context == 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
{
gl renderer: Rename everything called window to surface
2018-03-26 19:13:52 +00:00
self->gl_context = gdk_surface_create_gl_context (surface, error);
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
if (self->gl_context == NULL)
return 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
}
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
if (!gdk_gl_context_realize (self->gl_context, error))
return 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: Bind GL context to the GL profiler Similarly to how we bind it to the GL driver object used by the GSK GL renderer.
2016-07-27 10:34:20 +00:00
gdk_gl_context_make_current (self->gl_context);
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 GskGLDriver We can move the caching and management of textures, VAOs, and state of the GL machinery into a single object, GskGLDriver.
2016-07-08 15:21:13 +00:00
g_assert (self->gl_driver == NULL);
gsk: Bind GL context to the GL profiler Similarly to how we bind it to the GL driver object used by the GSK GL renderer.
2016-07-27 10:34:20 +00:00
self->gl_profiler = gsk_gl_profiler_new (self->gl_context);
Rework the GL renderer
2017-11-03 12:09:02 +00:00
self->gl_driver = gsk_gl_driver_new (self->gl_context);
gsk: Add GskGLDriver We can move the caching and management of textures, VAOs, and state of the GL machinery into a single object, GskGLDriver.
2016-07-08 15:21:13 +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
GSK_RENDERER_NOTE (renderer, OPENGL, g_message ("Creating buffers and programs"));
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
if (!gsk_gl_renderer_create_programs (self, error))
gsk: Rework how GLSL shaders are built The GL renderer should build the GLSL shaders using GskShaderBuilder. This allows us to separate the common parts into separate files, and assemble them as necessary, instead of shipping one big shader per type of GL API (GL3, GL legacy, and GLES).
2016-07-03 20:12:22 +00:00
return 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
Share glyph and icon caches Use the same texture atlases to back both the glyph and icon caches, and unify their sizes and management. Store big glyphs in separate textures, so all atlases have the same size. Tweak some of the eviction parameters. We share the caches across all GL contexts on a display, unless the GSK_NO_SHARED_CACHES env var is set.
2019-06-04 21:27:09 +00:00
self->atlases = get_texture_atlases_for_display (gdk_surface_get_display (surface));
self->glyph_cache = get_glyph_cache_for_display (gdk_surface_get_display (surface), self->atlases);
self->icon_cache = get_icon_cache_for_display (gdk_surface_get_display (surface), self->atlases);
gl renderer: Cache blurred outset shadow nodes Since these are particularly expensive to render and we have a pretty big one used in every client-side decorated window.
2018-07-08 18:08:15 +00:00
gsk_gl_shadow_cache_init (&self->shadow_cache);
gl: Add glyph cache Based on the one used by the vulkan renderer
2017-11-18 13:30:57 +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
return TRUE;
}
static void
gsk_gl_renderer_unrealize (GskRenderer *renderer)
{
GskGLRenderer *self = GSK_GL_RENDERER (renderer);
gl renderer: Properly delete all shader programs
2017-12-29 04:31:49 +00:00
guint i;
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: Bind GL context to the GL profiler Similarly to how we bind it to the GL driver object used by the GSK GL renderer.
2016-07-27 10:34:20 +00:00
if (self->gl_context == 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
return;
gsk: Bind GL context to the GL profiler Similarly to how we bind it to the GL driver object used by the GSK GL renderer.
2016-07-27 10:34:20 +00:00
gdk_gl_context_make_current (self->gl_context);
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: Move resource handling inside GskGLDriver We want the GL driver to cache as many resources as possible, so we can always ensure that we're in a consistent state, and we can handle state transitions more appropriately.
2016-07-20 16:55:35 +00:00
/* We don't need to iterate to destroy the associated GL resources,
* as they will be dropped when we finalize the GskGLDriver
*/
gl renderer: Rework once more Last time, I swear.
2017-11-22 10:32:23 +00:00
g_array_set_size (self->render_ops, 0);
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
gl renderer: Properly delete all shader programs
2017-12-29 04:31:49 +00:00
for (i = 0; i < GL_N_PROGRAMS; i ++)
glDeleteProgram (self->programs[i].id);
Rework the GL renderer
2017-11-03 12:09:02 +00:00
Share glyph and icon caches Use the same texture atlases to back both the glyph and icon caches, and unify their sizes and management. Store big glyphs in separate textures, so all atlases have the same size. Tweak some of the eviction parameters. We share the caches across all GL contexts on a display, unless the GSK_NO_SHARED_CACHES env var is set.
2019-06-04 21:27:09 +00:00
g_clear_pointer (&self->glyph_cache, gsk_gl_glyph_cache_unref);
g_clear_pointer (&self->icon_cache, gsk_gl_icon_cache_unref);
g_clear_pointer (&self->atlases, gsk_gl_texture_atlases_unref);
gl renderer: Cache blurred outset shadow nodes Since these are particularly expensive to render and we have a pretty big one used in every client-side decorated window.
2018-07-08 18:08:15 +00:00
gsk_gl_shadow_cache_free (&self->shadow_cache, self->gl_driver);
gl: Add glyph cache Based on the one used by the vulkan renderer
2017-11-18 13:30:57 +00:00
gsk: Add GL profiler We can use the GL_ARB_timer_query extension (available since OpenGL 3.2, and part of the OpenGL specification since version 3.3) to query the time elapsed when drawing each frame. This allows us to gather timing information on our use of the GPU.
2016-07-12 13:50:48 +00:00
g_clear_object (&self->gl_profiler);
gsk: Add GskGLDriver We can move the caching and management of textures, VAOs, and state of the GL machinery into a single object, GskGLDriver.
2016-07-08 15:21:13 +00:00
g_clear_object (&self->gl_driver);
gsk: Bind GL context to the GL profiler Similarly to how we bind it to the GL driver object used by the GSK GL renderer.
2016-07-27 10:34:20 +00:00
if (self->gl_context == gdk_gl_context_get_current ())
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
gdk_gl_context_clear_current ();
gskgl: Deal with being rerealized
2017-11-01 14:33:02 +00:00
g_clear_object (&self->gl_context);
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
}
gl renderer: Rework once more Last time, I swear.
2017-11-22 10:32:23 +00:00
static void
gsk_gl_renderer_clear_tree (GskGLRenderer *self)
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
{
gl renderer: Stop collecting VAOs in clear_tree We don't use that part of the gl driver anymore.
2017-11-23 09:28:30 +00:00
int removed_textures;
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
gl renderer: Rework once more Last time, I swear.
2017-11-22 10:32:23 +00:00
if (self->gl_context == NULL)
return;
gdk_gl_context_make_current (self->gl_context);
g_array_remove_range (self->render_ops, 0, self->render_ops->len);
removed_textures = gsk_gl_driver_collect_textures (self->gl_driver);
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: 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
GSK_RENDERER_NOTE (GSK_RENDERER (self), OPENGL, g_message ("Collected: %d textures", removed_textures));
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
}
Rework the GL renderer
2017-11-03 12:09:02 +00:00
static void
gl renderer: Rework once more Last time, I swear.
2017-11-22 10:32:23 +00:00
gsk_gl_renderer_clear (GskGLRenderer *self)
gsk: Add redirection to FBOs for opacity groups If a node is non-opaque and has a non-zero opacity we need to paint its contents and children first to an off screen buffer, and then render the resulting texture at the desired opacity — otherwise the opacities will combine and result in the wrong rendering.
2016-07-25 16:15:05 +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
GSK_RENDERER_NOTE (GSK_RENDERER (self), OPENGL, g_message ("Clearing viewport"));
gl renderer: Rework once more Last time, I swear.
2017-11-22 10:32:23 +00:00
glClearColor (0, 0, 0, 0);
glClear (GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT);
gsk: Add redirection to FBOs for opacity groups If a node is non-opaque and has a non-zero opacity we need to paint its contents and children first to an off screen buffer, and then render the resulting texture at the desired opacity — otherwise the opacities will combine and result in the wrong rendering.
2016-07-25 16:15:05 +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
static void
gl renderer: Rework once more Last time, I swear.
2017-11-22 10:32:23 +00:00
gsk_gl_renderer_setup_render_mode (GskGLRenderer *self)
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: move begin/end_frame vfuncs into the renderers
2018-03-28 13:01:34 +00:00
if (self->render_region == NULL)
{
gl renderer: Rework once more Last time, I swear.
2017-11-22 10:32:23 +00:00
glDisable (GL_SCISSOR_TEST);
gsk: move begin/end_frame vfuncs into the renderers
2018-03-28 13:01:34 +00:00
}
else
{
GdkSurface *surface = gsk_renderer_get_surface (GSK_RENDERER (self));
cairo_rectangle_int_t extents;
int surface_height;
gl renderer: Group render node types by render item creation
2017-11-20 13:30:46 +00:00
gsk: move begin/end_frame vfuncs into the renderers
2018-03-28 13:01:34 +00:00
g_assert (cairo_region_num_rectangles (self->render_region) == 1);
gl renderer: Group render node types by render item creation
2017-11-20 13:30:46 +00:00
gsk: move begin/end_frame vfuncs into the renderers
2018-03-28 13:01:34 +00:00
surface_height = gdk_surface_get_height (surface) * self->scale_factor;
cairo_region_get_rectangle (self->render_region, 0, &extents);
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: move begin/end_frame vfuncs into the renderers
2018-03-28 13:01:34 +00:00
glEnable (GL_SCISSOR_TEST);
glScissor (extents.x * self->scale_factor,
surface_height - (extents.height * self->scale_factor) - (extents.y * self->scale_factor),
extents.width * self->scale_factor,
extents.height * self->scale_factor);
}
gl renderer: Rework once more Last time, I swear.
2017-11-22 10:32:23 +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
gl renderer: Rework once more Last time, I swear.
2017-11-22 10:32:23 +00:00
static void
gsk_gl_renderer_add_render_ops (GskGLRenderer *self,
GskRenderNode *node,
RenderOpBuilder *builder)
{
gl renderer: Fix shadow nodes if the child is a container
2017-12-09 17:26:29 +00:00
const float min_x = builder->dx + node->bounds.origin.x;
const float min_y = builder->dy + node->bounds.origin.y;
gl renderer: Use one function per node-type So a profiler can actually tell me what's slow and not just point at _add_render_ops in all cases.
2017-12-08 12:12:43 +00:00
const float max_x = min_x + node->bounds.size.width;
const float max_y = min_y + node->bounds.size.height;
gl renderer: Rework once more Last time, I swear.
2017-11-22 10:32:23 +00:00
/* Default vertex data */
gl renderer: Implement simple shadow nodes
2017-12-01 09:27:31 +00:00
const GskQuadVertex vertex_data[GL_N_VERTICES] = {
gl renderer: Rework once more Last time, I swear.
2017-11-22 10:32:23 +00:00
{ { min_x, min_y }, { 0, 0 }, },
{ { min_x, max_y }, { 0, 1 }, },
{ { max_x, min_y }, { 1, 0 }, },
{ { max_x, max_y }, { 1, 1 }, },
{ { min_x, max_y }, { 0, 1 }, },
{ { max_x, min_y }, { 1, 0 }, },
};
gsk: Allow sampling between parent and child nodes
2016-06-30 16:06:31 +00:00
gl renderer: Skip all 0-sized nodes These will cause problems later on.
2018-03-25 09:47:04 +00:00
/* This can still happen, even if the render nodes are created using
* GtkSnapshot, so let's juse be safe. */
gl renderer: Ignore nodes with nan bounds This can happen for certain transform nodes. The transform node's child's bounds are fine, but the transform node bounds are all nan. Just ignore those bounds since we can't meaningfully render them anyway.
2019-02-26 05:49:59 +00:00
if (node->bounds.size.width == 0.0f || node->bounds.size.height == 0.0f ||
isnan (node->bounds.size.width) || isnan (node->bounds.size.height))
gl renderer: Skip all 0-sized nodes These will cause problems later on.
2018-03-25 09:47:04 +00:00
return;
gl renderer: Ignore nodes outside of the clip Pretty sure this will bite me later but for now we avoid rendering nodes that we are not going to see anyway.
2018-05-01 10:51:04 +00:00
/* Check whether the render node is entirely out of the current
* already transformed clip region */
{
graphene_rect_t transformed_node_bounds;
gl renderer: Save some matrix multiplications We do this for every single node, which is a little costly, especially since the common case for the modelview matrix these days is a simple translation. So, check whether the new modelview matrix is only a translation matrix and if so, don't do a full matrix multiplication per node.
2018-10-06 07:23:26 +00:00
ops_transform_bounds_modelview (builder,
&node->bounds,
&transformed_node_bounds);
gl renderer: Ignore nodes outside of the clip Pretty sure this will bite me later but for now we avoid rendering nodes that we are not going to see anyway.
2018-05-01 10:51:04 +00:00
gl renderer: Add a clip stack So we can check that the currently set clip is the first one and now intersect with it. This first clip is always the entire viewport or the entire render_area and we don't want to end up drawing things to a texture because of it.
2018-12-30 14:25:01 +00:00
if (!graphene_rect_intersection (&builder->current_clip->bounds,
gl renderer: Ignore nodes outside of the clip Pretty sure this will bite me later but for now we avoid rendering nodes that we are not going to see anyway.
2018-05-01 10:51:04 +00:00
&transformed_node_bounds, NULL))
return;
}
Rework the GL renderer
2017-11-03 12:09:02 +00:00
switch (gsk_render_node_get_node_type (node))
gsk: Ensure that non-drawing nodes are supported Non-drawing nodes should skip the texturing phase.
2016-08-09 15:30:13 +00:00
{
gl renderer: Rework once more Last time, I swear.
2017-11-22 10:32:23 +00:00
case GSK_NOT_A_RENDER_NODE:
g_assert_not_reached ();
Rework the GL renderer
2017-11-03 12:09:02 +00:00
gl renderer: Rework once more Last time, I swear.
2017-11-22 10:32:23 +00:00
case GSK_CONTAINER_NODE:
{
guint i, p;
gl renderer: Don't create framebuffer for texture opacity children Slowly a pattern emerges...
2017-11-16 11:20:35 +00:00
gl renderer: Rework once more Last time, I swear.
2017-11-22 10:32:23 +00:00
for (i = 0, p = gsk_container_node_get_n_children (node); i < p; i ++)
gl renderer: Don't create framebuffer for texture opacity children Slowly a pattern emerges...
2017-11-16 11:20:35 +00:00
{
gl renderer: Rework once more Last time, I swear.
2017-11-22 10:32:23 +00:00
GskRenderNode *child = gsk_container_node_get_child (node, i);
gl renderer: Don't create framebuffer for texture opacity children Slowly a pattern emerges...
2017-11-16 11:20:35 +00:00
gl renderer: Rework once more Last time, I swear.
2017-11-22 10:32:23 +00:00
gsk_gl_renderer_add_render_ops (self, child, builder);
gl renderer: Don't create framebuffer for texture opacity children Slowly a pattern emerges...
2017-11-16 11:20:35 +00:00
}
Rework the GL renderer
2017-11-03 12:09:02 +00:00
}
gl renderer: Rework once more Last time, I swear.
2017-11-22 10:32:23 +00:00
break;
gsk: Ensure that non-drawing nodes are supported Non-drawing nodes should skip the texturing phase.
2016-08-09 15:30:13 +00:00
gsk: Add GskDebugNode
2018-04-23 22:41:48 +00:00
case GSK_DEBUG_NODE:
glrenderer: Handle NULL debug messages
2019-05-21 03:41:06 +00:00
{
const char *message = gsk_debug_node_get_message (node);
if (message)
ops_push_debug_group (builder, message);
gsk_gl_renderer_add_render_ops (self,
gsk_debug_node_get_child (node),
builder);
if (message)
ops_pop_debug_group (builder);
}
gsk: Add GskDebugNode
2018-04-23 22:41:48 +00:00
break;
gl renderer: Rework once more Last time, I swear.
2017-11-22 10:32:23 +00:00
case GSK_COLOR_NODE:
gl renderer: Use one function per node-type So a profiler can actually tell me what's slow and not just point at _add_render_ops in all cases.
2017-12-08 12:12:43 +00:00
render_color_node (self, node, builder, vertex_data);
gl renderer: Rework once more Last time, I swear.
2017-11-22 10:32:23 +00:00
break;
gsk: Ensure that non-drawing nodes are supported Non-drawing nodes should skip the texturing phase.
2016-08-09 15:30:13 +00:00
Partially revert GskTexture → GdkTexture rename Excessive use of sed when moving GskTexture to GDK; the GskTextureNode should still live under the GSK namespace.
2017-11-04 15:03:03 +00:00
case GSK_TEXTURE_NODE:
gl renderer: Render GL textures upside down These come from an FBO so we need to flip the texture coords on the y axis, just like we do everywhere else.
2018-01-18 07:21:11 +00:00
render_texture_node (self, node, builder);
gl renderer: Rework once more Last time, I swear.
2017-11-22 10:32:23 +00:00
break;
gsk: Add GskTexture
2016-11-07 16:59:38 +00:00
gl renderer: Rework once more Last time, I swear.
2017-11-22 10:32:23 +00:00
case GSK_TRANSFORM_NODE:
gl renderer: Use one function per node-type So a profiler can actually tell me what's slow and not just point at _add_render_ops in all cases.
2017-12-08 12:12:43 +00:00
render_transform_node (self, node, builder);
gl renderer: Rework once more Last time, I swear.
2017-11-22 10:32:23 +00:00
break;
glrenderer: Handle color nodes
2017-01-06 19:53:12 +00:00
gl renderer: Rework once more Last time, I swear.
2017-11-22 10:32:23 +00:00
case GSK_OPACITY_NODE:
gl renderer: Use one function per node-type So a profiler can actually tell me what's slow and not just point at _add_render_ops in all cases.
2017-12-08 12:12:43 +00:00
render_opacity_node (self, node, builder);
gl renderer: Rework once more Last time, I swear.
2017-11-22 10:32:23 +00:00
break;
gsk: Rework GskTexture We do no longer bind textures to a renderer, instead they are a way for applications to provide texture data. For now, that's it. We've reverted to uploading it from scratch every frame.
2016-11-16 03:14:32 +00:00
Rework the GL renderer
2017-11-03 12:09:02 +00:00
case GSK_LINEAR_GRADIENT_NODE:
gl renderer: Use one function per node-type So a profiler can actually tell me what's slow and not just point at _add_render_ops in all cases.
2017-12-08 12:12:43 +00:00
render_linear_gradient_node (self, node, builder, vertex_data);
gl renderer: Rework once more Last time, I swear.
2017-11-22 10:32:23 +00:00
break;
case GSK_CLIP_NODE:
gl renderer: Use one function per node-type So a profiler can actually tell me what's slow and not just point at _add_render_ops in all cases.
2017-12-08 12:12:43 +00:00
render_clip_node (self, node, builder);
gl renderer: Rework once more Last time, I swear.
2017-11-22 10:32:23 +00:00
break;
case GSK_ROUNDED_CLIP_NODE:
gl renderer: Use one function per node-type So a profiler can actually tell me what's slow and not just point at _add_render_ops in all cases.
2017-12-08 12:12:43 +00:00
render_rounded_clip_node (self, node, builder);
gl renderer: Rework once more Last time, I swear.
2017-11-22 10:32:23 +00:00
break;
gsK: Move children handling to GskContainerNode
2016-12-12 18:30:41 +00:00
gl: Add glyph cache Based on the one used by the vulkan renderer
2017-11-18 13:30:57 +00:00
case GSK_TEXT_NODE:
gl renderer: Use one function per node-type So a profiler can actually tell me what's slow and not just point at _add_render_ops in all cases.
2017-12-08 12:12:43 +00:00
render_text_node (self, node, builder,
gl renderer: Fix shadow nodes if the child is a container
2017-12-09 17:26:29 +00:00
gsk_text_node_peek_color (node), FALSE);
gl renderer: Rework once more Last time, I swear.
2017-11-22 10:32:23 +00:00
break;
gl renderer: Implement simple shadow nodes
2017-12-01 09:27:31 +00:00
gl renderer: Implement color matrix nodes again
2017-11-24 09:32:08 +00:00
case GSK_COLOR_MATRIX_NODE:
gl renderer: Use one function per node-type So a profiler can actually tell me what's slow and not just point at _add_render_ops in all cases.
2017-12-08 12:12:43 +00:00
render_color_matrix_node (self, node, builder, vertex_data);
gl renderer: Implement color matrix nodes again
2017-11-24 09:32:08 +00:00
break;
gl renderer: Implement blur nodes
2017-11-25 07:56:50 +00:00
case GSK_BLUR_NODE:
gl renderer: Use one function per node-type So a profiler can actually tell me what's slow and not just point at _add_render_ops in all cases.
2017-12-08 12:12:43 +00:00
render_blur_node (self, node, builder, vertex_data);
gl renderer: Implement blur nodes
2017-11-25 07:56:50 +00:00
break;
gl renderer: Implement unblurred inset shadows
2017-11-30 15:48:03 +00:00
case GSK_INSET_SHADOW_NODE:
gl renderer: Use one function per node-type So a profiler can actually tell me what's slow and not just point at _add_render_ops in all cases.
2017-12-08 12:12:43 +00:00
render_inset_shadow_node (self, node, builder, vertex_data);
gl renderer: Implement unblurred inset shadows
2017-11-30 15:48:03 +00:00
break;
gl renderer: Implement unblurred outset shadows
2017-12-01 07:30:11 +00:00
case GSK_OUTSET_SHADOW_NODE:
gl renderer: Render unblurred outset shadows differently We don't need to draw anything to a texure for those.
2018-01-15 09:55:40 +00:00
if (gsk_outset_shadow_node_get_blur_radius (node) > 0)
render_outset_shadow_node (self, node, builder);
else
render_unblurred_outset_shadow_node (self, node, builder, vertex_data);
gl renderer: Implement unblurred outset shadows
2017-12-01 07:30:11 +00:00
break;
gl renderer: Implement simple shadow nodes
2017-12-01 09:27:31 +00:00
case GSK_SHADOW_NODE:
gl renderer: Use one function per node-type So a profiler can actually tell me what's slow and not just point at _add_render_ops in all cases.
2017-12-08 12:12:43 +00:00
render_shadow_node (self, node, builder, vertex_data);
gl renderer: Implement simple shadow nodes
2017-12-01 09:27:31 +00:00
break;
gl renderer: Implement unblurred inset shadows
2017-11-30 15:48:03 +00:00
gl renderer: Implement unblurred outset shadows
2017-12-01 07:30:11 +00:00
case GSK_BORDER_NODE:
gl renderer: Use one function per node-type So a profiler can actually tell me what's slow and not just point at _add_render_ops in all cases.
2017-12-08 12:12:43 +00:00
render_border_node (self, node, builder);
gl renderer: Implement simple border nodes
2017-12-01 10:55:10 +00:00
break;
Rework the GL renderer
2017-11-03 12:09:02 +00:00
case GSK_CROSS_FADE_NODE:
gl renderer: Implement cross fade nodes
2017-12-11 07:22:28 +00:00
render_cross_fade_node (self, node, builder);
break;
Rework the GL renderer
2017-11-03 12:09:02 +00:00
case GSK_BLEND_NODE:
gl renderer: Add simple blend node implementation
2019-04-28 05:46:17 +00:00
render_blend_node (self, node, builder);
break;
case GSK_REPEATING_LINEAR_GRADIENT_NODE:
Rework the GL renderer
2017-11-03 12:09:02 +00:00
case GSK_REPEAT_NODE:
gl renderer: Remove cairo node special case
2018-03-25 09:46:48 +00:00
case GSK_CAIRO_NODE:
gsk: Add fallback code to renderers This code makes renderers fall back to Cairo rendering if they don't know how to handle a render node's type. This allows adding new render nodes with impunity.
2016-12-13 03:20:04 +00:00
default:
{
gl renderer: Render fallback nodes upside down We stuff both gl-drawn and cairo-drawn textures into the same cache, so we can't really assume that we need to draw any of them flipped or not. Fix this by drawing fallback stuff upside down and then using upside-down vertex data for everything. Fixes #1897
2019-05-18 11:45:19 +00:00
render_fallback_node (self, node, builder);
gl renderer: Rework once more Last time, I swear.
2017-11-22 10:32:23 +00:00
}
Rework the GL renderer
2017-11-03 12:09:02 +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
}
gl renderer: Don't draw texture nodes to a framebuffer We don't need to create a texture from a texture node. We can simply use its texture instead and draw it however we want.
2017-11-24 09:43:17 +00:00
static void
gl renderer: Refactor add_offscreen_ops Use a graphene_rect_t for the node bounds instead of 4 floats. This makes it simpler to pass the size in without the offset applied.
2018-12-02 08:05:50 +00:00
add_offscreen_ops (GskGLRenderer *self,
RenderOpBuilder *builder,
const graphene_rect_t *bounds,
GskRenderNode *child_node,
Consider all offscreen drawings for the icon cache
2019-06-04 17:28:59 +00:00
TextureRegion *texture_region_out,
gl renderer: Refactor add_offscreen_ops Use a graphene_rect_t for the node bounds instead of 4 floats. This makes it simpler to pass the size in without the offset applied.
2018-12-02 08:05:50 +00:00
gboolean *is_offscreen,
gl renderer: Support (not) resetting the opacity for offscreen nodes We usually want to do that, but it's wrong for e.g. crossfade nodes.
2019-01-18 12:06:41 +00:00
guint flags)
gl renderer: Factor out a helper function for offscreen drawing
2017-11-24 09:18:51 +00:00
{
gl renderer: Render everyhing according to MV scale And not the surface's scale factor. This way the magnifier works.
2018-04-11 09:20:50 +00:00
const float scale = ops_get_scale (builder);
gl renderer: Round size up when rendering to a texture Both the clip we use and the viewport we set should contain the entire texture size and not potentially clip the last pixel.
2019-02-23 03:50:25 +00:00
const float width = ceilf (bounds->size.width * scale);
const float height = ceilf (bounds->size.height * scale);
gl renderer: Reset offset when rendering offscreen We want to apply the offset to the rendered texture, not to the offscreen-rendered content.
2018-12-02 07:12:44 +00:00
const float dx = builder->dx;
const float dy = builder->dy;
gl renderer: Factor out a helper function for offscreen drawing
2017-11-24 09:18:51 +00:00
int render_target;
int prev_render_target;
RenderOp op;
gl renderer: Pass correct matrix category when rendering offscreen We can't just pretend we have an identity matrix when we are actually scaling. This fixes the node editor sometimes not drawing things when rendering to a texture. We were mistakenly discaring render nodes because the bounds transformation was wrong.
2019-05-20 10:10:12 +00:00
graphene_matrix_t modelview;
gl renderer: Factor out a helper function for offscreen drawing
2017-11-24 09:18:51 +00:00
graphene_matrix_t prev_projection;
graphene_rect_t prev_viewport;
graphene_matrix_t item_proj;
gl renderer: Reset opacity when rendering to a texture The opacity will already be applied when rendering the final texture.
2018-12-02 15:03:08 +00:00
float prev_opacity;
gl renderer: Cache offscreen textures per node, not size
2018-11-28 17:40:48 +00:00
int texture_id = 0;
gl renderer: Factor out a helper function for offscreen drawing
2017-11-24 09:18:51 +00:00
gl renderer: Don't draw texture nodes to a framebuffer We don't need to create a texture from a texture node. We can simply use its texture instead and draw it however we want.
2017-11-24 09:43:17 +00:00
/* We need the child node as a texture. If it already is one, we don't need to draw
* it on a framebuffer of course. */
gl renderer: Support (not) resetting the opacity for offscreen nodes We usually want to do that, but it's wrong for e.g. crossfade nodes.
2019-01-18 12:06:41 +00:00
if (gsk_render_node_get_node_type (child_node) == GSK_TEXTURE_NODE &&
(flags & FORCE_OFFSCREEN) == 0)
gl renderer: Don't draw texture nodes to a framebuffer We don't need to create a texture from a texture node. We can simply use its texture instead and draw it however we want.
2017-11-24 09:43:17 +00:00
{
GdkTexture *texture = gsk_texture_node_get_texture (child_node);
Consider all offscreen drawings for the icon cache
2019-06-04 17:28:59 +00:00
upload_texture (self, texture, texture_region_out);
gl renderer: Don't draw texture nodes to a framebuffer We don't need to create a texture from a texture node. We can simply use its texture instead and draw it however we want.
2017-11-24 09:43:17 +00:00
*is_offscreen = FALSE;
return;
}
gl renderer: Factor out a helper function for offscreen drawing
2017-11-24 09:18:51 +00:00
gl renderer: Cache offscreen textures per node, not size
2018-11-28 17:40:48 +00:00
/* Check if we've already cached the drawn texture. */
{
const int cached_id = gsk_gl_driver_get_texture_for_pointer (self->gl_driver, child_node);
if (cached_id != 0)
{
Consider all offscreen drawings for the icon cache
2019-06-04 17:28:59 +00:00
init_full_texture_region (texture_region_out, cached_id);
gl renderer: Cache offscreen textures per node, not size
2018-11-28 17:40:48 +00:00
/* We didn't render it offscreen, but hand out an offscreen texture id */
*is_offscreen = TRUE;
return;
}
}
gl renderer: Make creating render targets easier
2019-05-22 05:10:57 +00:00
gsk_gl_driver_create_render_target (self->gl_driver, width, height, &texture_id, &render_target);
GskGLRenderer: Label various gl objects This means the names are more useful in tools like renderdoc.
2019-04-24 11:27:43 +00:00
gdk_gl_context_label_object_printf (self->gl_context, GL_TEXTURE, texture_id,
"Offscreen<%s> %d", child_node->node_class->type_name, texture_id);
gdk_gl_context_label_object_printf (self->gl_context, GL_FRAMEBUFFER, render_target,
"Offscreen<%s> FB %d", child_node->node_class->type_name, render_target);
gl renderer: Factor out a helper function for offscreen drawing
2017-11-24 09:18:51 +00:00
graphene_matrix_init_ortho (&item_proj,
gl renderer: Refactor add_offscreen_ops Use a graphene_rect_t for the node bounds instead of 4 floats. This makes it simpler to pass the size in without the offset applied.
2018-12-02 08:05:50 +00:00
bounds->origin.x * scale,
(bounds->origin.x + bounds->size.width) * scale,
bounds->origin.y * scale,
(bounds->origin.y + bounds->size.height) * scale,
gl renderer: Factor out a helper function for offscreen drawing
2017-11-24 09:18:51 +00:00
ORTHO_NEAR_PLANE, ORTHO_FAR_PLANE);
graphene_matrix_scale (&item_proj, 1, -1, 1);
gl renderer: Pass correct matrix category when rendering offscreen We can't just pretend we have an identity matrix when we are actually scaling. This fixes the node editor sometimes not drawing things when rendering to a texture. We were mistakenly discaring render nodes because the bounds transformation was wrong.
2019-05-20 10:10:12 +00:00
graphene_matrix_init_scale (&modelview, scale, scale, 1);
gl renderer: Factor out a helper function for offscreen drawing
2017-11-24 09:18:51 +00:00
prev_render_target = ops_set_render_target (builder, render_target);
/* Clear since we use this rendertarget for the first time */
op.op = OP_CLEAR;
ops_add (builder, &op);
prev_projection = ops_set_projection (builder, &item_proj);
gl renderer: Use GskTransform in render ops builder for the modelview matrix. We need this later.
2019-06-02 07:55:11 +00:00
ops_set_modelview (builder, gsk_transform_scale (NULL, scale, scale));
gl renderer: Refactor add_offscreen_ops Use a graphene_rect_t for the node bounds instead of 4 floats. This makes it simpler to pass the size in without the offset applied.
2018-12-02 08:05:50 +00:00
prev_viewport = ops_set_viewport (builder,
&GRAPHENE_RECT_INIT (bounds->origin.x * scale,
bounds->origin.y * scale,
width, height));
gl renderer: Support (not) resetting the opacity for offscreen nodes We usually want to do that, but it's wrong for e.g. crossfade nodes.
2019-01-18 12:06:41 +00:00
if (flags & RESET_CLIP)
gl renderer: Add a clip stack So we can check that the currently set clip is the first one and now intersect with it. This first clip is always the entire viewport or the entire render_area and we don't want to end up drawing things to a texture because of it.
2018-12-30 14:25:01 +00:00
ops_push_clip (builder,
&GSK_ROUNDED_RECT_INIT (bounds->origin.x * scale,
bounds->origin.y * scale,
width, height));
gl renderer: Refactor add_offscreen_ops Use a graphene_rect_t for the node bounds instead of 4 floats. This makes it simpler to pass the size in without the offset applied.
2018-12-02 08:05:50 +00:00
gl renderer: Reset offset when rendering offscreen We want to apply the offset to the rendered texture, not to the offscreen-rendered content.
2018-12-02 07:12:44 +00:00
builder->dx = 0;
builder->dy = 0;
gl renderer: Support (not) resetting the opacity for offscreen nodes We usually want to do that, but it's wrong for e.g. crossfade nodes.
2019-01-18 12:06:41 +00:00
if (flags & RESET_OPACITY)
prev_opacity = ops_set_opacity (builder, 1.0);
gl renderer: Factor out a helper function for offscreen drawing
2017-11-24 09:18:51 +00:00
gsk_gl_renderer_add_render_ops (self, child_node, builder);
gl renderer: Add debug code to dump framebuffer This way we can specify it on specific add_offscreen_ops callsites.
2019-03-31 04:14:41 +00:00
#ifdef G_ENABLE_DEBUG
if (G_UNLIKELY (flags & DUMP_FRAMEBUFFER))
{
static int k;
ops_dump_framebuffer (builder, g_strdup_printf ("%s_%p_%d.png",
child_node->node_class->type_name,
child_node,
k ++),
width, height);
}
#endif
gl renderer: Support (not) resetting the opacity for offscreen nodes We usually want to do that, but it's wrong for e.g. crossfade nodes.
2019-01-18 12:06:41 +00:00
if (flags & RESET_OPACITY)
ops_set_opacity (builder, prev_opacity);
gl renderer: Reset offset when rendering offscreen We want to apply the offset to the rendered texture, not to the offscreen-rendered content.
2018-12-02 07:12:44 +00:00
builder->dx = dx;
builder->dy = dy;
gl renderer: Support (not) resetting the opacity for offscreen nodes We usually want to do that, but it's wrong for e.g. crossfade nodes.
2019-01-18 12:06:41 +00:00
if (flags & RESET_CLIP)
gl renderer: Add a clip stack So we can check that the currently set clip is the first one and now intersect with it. This first clip is always the entire viewport or the entire render_area and we don't want to end up drawing things to a texture because of it.
2018-12-30 14:25:01 +00:00
ops_pop_clip (builder);
gl renderer: Draw rounded clip child to a texture And then clip the texture using the current (maybe also rounded) clip. This way, the result is correct. We don't necessarily have to do the offscreen drawing in any case, but got the safe route for now.
2018-03-14 11:36:32 +00:00
gl renderer: Factor out a helper function for offscreen drawing
2017-11-24 09:18:51 +00:00
ops_set_viewport (builder, &prev_viewport);
gl renderer: Use stack to keep track of modelview matrix So we can avoid calculating metadata for matrices all the time.
2018-11-26 16:52:35 +00:00
ops_pop_modelview (builder);
gl renderer: Factor out a helper function for offscreen drawing
2017-11-24 09:18:51 +00:00
ops_set_projection (builder, &prev_projection);
ops_set_render_target (builder, prev_render_target);
gl renderer: Don't draw texture nodes to a framebuffer We don't need to create a texture from a texture node. We can simply use its texture instead and draw it however we want.
2017-11-24 09:43:17 +00:00
*is_offscreen = TRUE;
Consider all offscreen drawings for the icon cache
2019-06-04 17:28:59 +00:00
init_full_texture_region (texture_region_out, texture_id);
gl renderer: Cache offscreen textures per node, not size
2018-11-28 17:40:48 +00:00
gsk_gl_driver_set_texture_for_pointer (self->gl_driver, child_node, texture_id);
gl renderer: Factor out a helper function for offscreen drawing
2017-11-24 09:18:51 +00:00
}
Rework the GL renderer
2017-11-03 12:09:02 +00:00
static void
gl renderer: Rework once more Last time, I swear.
2017-11-22 10:32:23 +00:00
gsk_gl_renderer_render_ops (GskGLRenderer *self,
gsize vertex_data_size)
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
{
gl renderer: Rework once more Last time, I swear.
2017-11-22 10:32:23 +00:00
guint i;
guint n_ops = self->render_ops->len;
const Program *program = NULL;
gsize buffer_index = 0;
float *vertex_data = g_malloc (vertex_data_size);
gl renderer: Save clip in every node
2017-11-16 20:04:18 +00:00
gl renderer: Rework once more Last time, I swear.
2017-11-22 10:32:23 +00:00
/*g_message ("%s: Buffer size: %ld", __FUNCTION__, vertex_data_size);*/
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: Move resource handling inside GskGLDriver We want the GL driver to cache as many resources as possible, so we can always ensure that we're in a consistent state, and we can handle state transitions more appropriately.
2016-07-20 16:55:35 +00:00
gl renderer: Rework once more Last time, I swear.
2017-11-22 10:32:23 +00:00
GLuint buffer_id, vao_id;
glGenVertexArrays (1, &vao_id);
glBindVertexArray (vao_id);
gsk: Flush the GL render items cache Whenever the render tree changes we want to drop the RenderItem arrays, as each item contains a pointer to the GskRenderNode which becomes dangling once the root node changed.
2016-04-26 13:23:12 +00:00
gl renderer: Rework once more Last time, I swear.
2017-11-22 10:32:23 +00:00
glGenBuffers (1, &buffer_id);
glBindBuffer (GL_ARRAY_BUFFER, buffer_id);
gsk: Move resource handling inside GskGLDriver We want the GL driver to cache as many resources as possible, so we can always ensure that we're in a consistent state, and we can handle state transitions more appropriately.
2016-07-20 16:55:35 +00:00
gsk: Recycle textures across frames We keep the textures used inside a frame around until the end of the following frame; whenever we need a texture with the same size, and it's not marked in use, then we just reuse the existing texture.
2016-08-04 11:37:54 +00:00
gl renderer: Rework once more Last time, I swear.
2017-11-22 10:32:23 +00:00
// Fill buffer data
for (i = 0; i < n_ops; i ++)
{
const RenderOp *op = &g_array_index (self->render_ops, RenderOp, i);
gsk: Flush the GL render items cache Whenever the render tree changes we want to drop the RenderItem arrays, as each item contains a pointer to the GskRenderNode which becomes dangling once the root node changed.
2016-04-26 13:23:12 +00:00
gl renderer: Rework once more Last time, I swear.
2017-11-22 10:32:23 +00:00
if (op->op == OP_CHANGE_VAO)
{
gl renderer: Move render ops into separate file
2017-11-22 20:02:50 +00:00
memcpy (vertex_data + buffer_index, &op->vertex_data, sizeof (GskQuadVertex) * GL_N_VERTICES);
buffer_index += sizeof (GskQuadVertex) * GL_N_VERTICES / sizeof (float);
gl renderer: Rework once more Last time, I swear.
2017-11-22 10:32:23 +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
gl renderer: Rework once more Last time, I swear.
2017-11-22 10:32:23 +00:00
// Set buffer data
glBufferData (GL_ARRAY_BUFFER, vertex_data_size, vertex_data, GL_STATIC_DRAW);
gdkgl: Add gdk_gl_context_get_damage() This is a way to query the damaged area of the backbuffer. The GL renderer uses this to compute the extents of that damage region (computed via buffer age) and use them to minimize the area to redraw. This changes the semantics of GL rendering to "When calling gdk_window_begin_frame() with a GL context, the area by gdk_gl_context_get_damage() needs to be redrawn and every other pixel of the backbuffer is guaranteed to be correct. After gdk_window_end_frame() on a GL-drawn window, the whole backbuffer must be correct. We can always glXBufferSwap() now because of this.
2016-12-04 15:33:13 +00:00
gl renderer: Rework once more Last time, I swear.
2017-11-22 10:32:23 +00:00
// Describe buffer contents
Rework the GL renderer
2017-11-03 12:09:02 +00:00
gl renderer: Rework once more Last time, I swear.
2017-11-22 10:32:23 +00:00
/* 0 = position location */
glEnableVertexAttribArray (0);
glVertexAttribPointer (0, 2, GL_FLOAT, GL_FALSE,
sizeof (GskQuadVertex),
(void *) G_STRUCT_OFFSET (GskQuadVertex, position));
/* 1 = texture coord location */
glEnableVertexAttribArray (1);
glVertexAttribPointer (1, 2, GL_FLOAT, GL_FALSE,
sizeof (GskQuadVertex),
(void *) G_STRUCT_OFFSET (GskQuadVertex, uv));
gsk: Take scale factor into account when setting up the gl scissor
2017-03-20 09:52:58 +00:00
gl renderer: Rework once more Last time, I swear.
2017-11-22 10:32:23 +00:00
for (i = 0; i < n_ops; i ++)
{
const RenderOp *op = &g_array_index (self->render_ops, RenderOp, i);
Rework the GL renderer
2017-11-03 12:09:02 +00:00
gl renderer: Rework once more Last time, I swear.
2017-11-22 10:32:23 +00:00
if (op->op == OP_NONE ||
op->op == OP_CHANGE_VAO)
continue;
Rework the GL renderer
2017-11-03 12:09:02 +00:00
GskGLRenderer: Add debug groups This adds debug groups in various places, including the debug nodes if those are in use. This makes the traces in tools like renderdoc much easier to read.
2019-04-24 11:28:11 +00:00
if (op->op != OP_PUSH_DEBUG_GROUP &&
op->op != OP_POP_DEBUG_GROUP &&
op->op != OP_CHANGE_PROGRAM &&
gl renderer: try doing outset box shadows Still fall back in cases we can't handle that way.
2017-12-21 17:09:32 +00:00
op->op != OP_CHANGE_RENDER_TARGET &&
op->op != OP_CLEAR &&
gl renderer: Ignore render ops before we have a valid program
2017-12-08 19:43:47 +00:00
program == NULL)
continue;
gl renderer: Rework once more Last time, I swear.
2017-11-22 10:32:23 +00:00
OP_PRINT ("Op %u: %u", i, op->op);
gsk: Take scale factor into account when setting up the gl scissor
2017-03-20 09:52:58 +00:00
gl renderer: Rework once more Last time, I swear.
2017-11-22 10:32:23 +00:00
switch (op->op)
{
case OP_CHANGE_PROJECTION:
gl renderer: Use one function per op type to apply data
2017-12-16 09:02:03 +00:00
apply_projection_op (program, op);
gl renderer: Rework once more Last time, I swear.
2017-11-22 10:32:23 +00:00
break;
case OP_CHANGE_MODELVIEW:
gl renderer: Use one function per op type to apply data
2017-12-16 09:02:03 +00:00
apply_modelview_op (program, op);
gl renderer: Rework once more Last time, I swear.
2017-11-22 10:32:23 +00:00
break;
case OP_CHANGE_PROGRAM:
gl renderer: Use one function per op type to apply data
2017-12-16 09:02:03 +00:00
apply_program_op (program, op);
gl renderer: Rework once more Last time, I swear.
2017-11-22 10:32:23 +00:00
program = op->program;
break;
case OP_CHANGE_RENDER_TARGET:
gl renderer: Use one function per op type to apply data
2017-12-16 09:02:03 +00:00
apply_render_target_op (self, program, op);
gl renderer: Move render ops into separate file
2017-11-22 20:02:50 +00:00
break;
case OP_CLEAR:
glClearColor (0, 0, 0, 0);
glClear (GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT);
gl renderer: Rework once more Last time, I swear.
2017-11-22 10:32:23 +00:00
break;
case OP_CHANGE_VIEWPORT:
gl renderer: Use one function per op type to apply data
2017-12-16 09:02:03 +00:00
apply_viewport_op (program, op);
gl renderer: Rework once more Last time, I swear.
2017-11-22 10:32:23 +00:00
break;
case OP_CHANGE_OPACITY:
gl renderer: Use one function per op type to apply data
2017-12-16 09:02:03 +00:00
apply_opacity_op (program, op);
gl renderer: Rework once more Last time, I swear.
2017-11-22 10:32:23 +00:00
break;
gl renderer: Implement color matrix nodes again
2017-11-24 09:32:08 +00:00
case OP_CHANGE_COLOR_MATRIX:
gl renderer: Use one function per op type to apply data
2017-12-16 09:02:03 +00:00
apply_color_matrix_op (program, op);
gl renderer: Implement color matrix nodes again
2017-11-24 09:32:08 +00:00
break;
gl renderer: Rework once more Last time, I swear.
2017-11-22 10:32:23 +00:00
case OP_CHANGE_COLOR:
gl renderer: draw all outset shadows Instead of falling back to cairo for most of them.
2017-12-28 15:41:32 +00:00
/*g_assert (program == &self->color_program || program == &self->coloring_program ||*/
/*program == &self->shadow_program);*/
gl renderer: Use one function per op type to apply data
2017-12-16 09:02:03 +00:00
apply_color_op (program, op);
gl renderer: Rework once more Last time, I swear.
2017-11-22 10:32:23 +00:00
break;
gl renderer: Keep track of border program state
2017-12-05 07:38:42 +00:00
case OP_CHANGE_BORDER_COLOR:
gl renderer: Use one function per op type to apply data
2017-12-16 09:02:03 +00:00
apply_border_color_op (program, op);
gl renderer: Keep track of border program state
2017-12-05 07:38:42 +00:00
break;
gl renderer: Rework once more Last time, I swear.
2017-11-22 10:32:23 +00:00
case OP_CHANGE_CLIP:
gl renderer: Use one function per op type to apply data
2017-12-16 09:02:03 +00:00
apply_clip_op (program, op);
gl renderer: Rework once more Last time, I swear.
2017-11-22 10:32:23 +00:00
break;
case OP_CHANGE_SOURCE_TEXTURE:
gl renderer: Use one function per op type to apply data
2017-12-16 09:02:03 +00:00
apply_source_texture_op (program, op);
gl renderer: Rework once more Last time, I swear.
2017-11-22 10:32:23 +00:00
break;
gl renderer: Implement cross fade nodes
2017-12-11 07:22:28 +00:00
case OP_CHANGE_CROSS_FADE:
g_assert (program == &self->cross_fade_program);
gl renderer: Use one function per op type to apply data
2017-12-16 09:02:03 +00:00
apply_cross_fade_op (program, op);
gl renderer: Implement cross fade nodes
2017-12-11 07:22:28 +00:00
break;
gl renderer: Add simple blend node implementation
2019-04-28 05:46:17 +00:00
case OP_CHANGE_BLEND:
g_assert (program == &self->blend_program);
apply_blend_op (program, op);
break;
gl renderer: Rework once more Last time, I swear.
2017-11-22 10:32:23 +00:00
case OP_CHANGE_LINEAR_GRADIENT:
gl renderer: Use one function per op type to apply data
2017-12-16 09:02:03 +00:00
apply_linear_gradient_op (program, op);
gl renderer: Rework once more Last time, I swear.
2017-11-22 10:32:23 +00:00
break;
gl renderer: try doing outset box shadows Still fall back in cases we can't handle that way.
2017-12-21 17:09:32 +00:00
case OP_CHANGE_BLUR:
gl renderer: Use one function per op type to apply data
2017-12-16 09:02:03 +00:00
apply_blur_op (program, op);
gl renderer: Implement blur nodes
2017-11-25 07:56:50 +00:00
break;
gl renderer: try doing outset box shadows Still fall back in cases we can't handle that way.
2017-12-21 17:09:32 +00:00
case OP_CHANGE_INSET_SHADOW:
gl renderer: Use one function per op type to apply data
2017-12-16 09:02:03 +00:00
apply_inset_shadow_op (program, op);
gl renderer: Implement unblurred inset shadows
2017-11-30 15:48:03 +00:00
break;
gl renderer: try doing outset box shadows Still fall back in cases we can't handle that way.
2017-12-21 17:09:32 +00:00
case OP_CHANGE_OUTSET_SHADOW:
gl renderer: Use one function per op type to apply data
2017-12-16 09:02:03 +00:00
apply_outset_shadow_op (program, op);
gl renderer: Implement unblurred outset shadows
2017-12-01 07:30:11 +00:00
break;
gl renderer: Implement simple border nodes
2017-12-01 10:55:10 +00:00
case OP_CHANGE_BORDER:
gl renderer: Use one function per op type to apply data
2017-12-16 09:02:03 +00:00
apply_border_op (program, op);
gl renderer: Implement simple border nodes
2017-12-01 10:55:10 +00:00
break;
gl renderer: Track border width state separately
2018-12-05 09:44:11 +00:00
case OP_CHANGE_BORDER_WIDTH:
apply_border_width_op (program, op);
break;
gl renderer: Render unblurred outset shadows differently We don't need to draw anything to a texure for those.
2018-01-15 09:55:40 +00:00
case OP_CHANGE_UNBLURRED_OUTSET_SHADOW:
apply_unblurred_outset_shadow_op (program, op);
break;
gl renderer: Rework once more Last time, I swear.
2017-11-22 10:32:23 +00:00
case OP_DRAW:
gl renderer: Fix debugging output
2017-12-01 11:29:27 +00:00
OP_PRINT (" -> draw %ld, size %ld and program %d\n",
op->draw.vao_offset, op->draw.vao_size, program->index);
gl renderer: Remove some unused members
2017-11-25 06:51:00 +00:00
glDrawArrays (GL_TRIANGLES, op->draw.vao_offset, op->draw.vao_size);
gl renderer: Rework once more Last time, I swear.
2017-11-22 10:32:23 +00:00
break;
gl renderer: add render ops for dumping the framebuffer So offscreen rendering can be properly debugged.
2018-12-02 07:12:09 +00:00
case OP_DUMP_FRAMEBUFFER:
dump_framebuffer (op->dump.filename, op->dump.width, op->dump.height);
break;
GskGLRenderer: Add debug groups This adds debug groups in various places, including the debug nodes if those are in use. This makes the traces in tools like renderdoc much easier to read.
2019-04-24 11:28:11 +00:00
case OP_PUSH_DEBUG_GROUP:
gdk_gl_context_push_debug_group (self->gl_context, op->debug_group.text);
break;
case OP_POP_DEBUG_GROUP:
gdk_gl_context_pop_debug_group (self->gl_context);
break;
gl renderer: Rework once more Last time, I swear.
2017-11-22 10:32:23 +00:00
default:
g_warn_if_reached ();
}
Rework the GL renderer
2017-11-03 12:09:02 +00:00
gl renderer: Rework once more Last time, I swear.
2017-11-22 10:32:23 +00:00
OP_PRINT ("\n");
}
gdkgl: Add gdk_gl_context_get_damage() This is a way to query the damaged area of the backbuffer. The GL renderer uses this to compute the extents of that damage region (computed via buffer age) and use them to minimize the area to redraw. This changes the semantics of GL rendering to "When calling gdk_window_begin_frame() with a GL context, the area by gdk_gl_context_get_damage() needs to be redrawn and every other pixel of the backbuffer is guaranteed to be correct. After gdk_window_end_frame() on a GL-drawn window, the whole backbuffer must be correct. We can always glXBufferSwap() now because of this.
2016-12-04 15:33:13 +00:00
gl renderer: Rework once more Last time, I swear.
2017-11-22 10:32:23 +00:00
/* Done drawing, destroy the buffer again.
* TODO: Can we reuse the memory, though? */
g_free (vertex_data);
gl renderer: Don't leak gl resources
2017-12-16 01:37:03 +00:00
glDeleteVertexArrays (1, &vao_id);
glDeleteBuffers (1, &buffer_id);
gdkgl: Add gdk_gl_context_get_damage() This is a way to query the damaged area of the backbuffer. The GL renderer uses this to compute the extents of that damage region (computed via buffer age) and use them to minimize the area to redraw. This changes the semantics of GL rendering to "When calling gdk_window_begin_frame() with a GL context, the area by gdk_gl_context_get_damage() needs to be redrawn and every other pixel of the backbuffer is guaranteed to be correct. After gdk_window_end_frame() on a GL-drawn window, the whole backbuffer must be correct. We can always glXBufferSwap() now because of this.
2016-12-04 15:33:13 +00:00
}
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: Implement gsk_renderer_render_texture() on GL
2016-12-22 19:01:52 +00:00
gsk_gl_renderer_do_render (GskRenderer *renderer,
GskRenderNode *root,
const graphene_rect_t *viewport,
gl renderer: Rename texture_id parameter to fbo_id So this makes sense again.
2018-04-21 08:13:16 +00:00
int fbo_id,
gsk: Implement gsk_renderer_render_texture() on GL
2016-12-22 19:01:52 +00:00
int scale_factor)
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
{
GskGLRenderer *self = GSK_GL_RENDERER (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
graphene_matrix_t modelview, projection;
gl renderer: Keep op builder around GL keeps the unoform state per-program, but not per-frame. So, we can't pretend that this works for us. Keep the RenderOpBuilder around for the entire lifetime of the renderer instead.
2019-04-24 15:55:14 +00:00
gsize buffer_size;
gsk: Add GskProfiler to GskRenderer The profiler instance is per-renderer, and is accesible to implementations.
2016-08-03 15:51:21 +00:00
#ifdef G_ENABLE_DEBUG
GskProfiler *profiler;
gsk: Add tracing to the gl renderer Emit the equivalent of the cpu-time counter in the inspector.
2018-05-19 19:25:17 +00:00
gint64 gpu_time, cpu_time, start_time;
gsk: Add GskProfiler to GskRenderer The profiler instance is per-renderer, and is accesible to implementations.
2016-08-03 15:51:21 +00:00
#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: Make GskRenderer.render() drawing context-agnostic We're going to need to allow rendering on a specific cairo_t in order to implement fallback code paths inside GTK; this means that there will be times when we have a transient GskRenderer instance that does not have a GdkDrawingContext to draw on. Instead of adding a new render() implementation for those cases and then decide which one to use, we can remove the drawing context argument from the virtual function itself, and allow using a NULL GdkDrawingContext when calling gsk_renderer_render(). A later commit will add a generic function to create a transient GskRenderer with a cairo_t attached to it. Renderers inside GSK will have to check whether we have access to a GdkDrawingContext, in which case we're going to use it; or if we have access to a cairo_t and a window.
2016-08-24 15:21:50 +00:00
#ifdef G_ENABLE_DEBUG
gsk: Add GskProfiler to GskRenderer The profiler instance is per-renderer, and is accesible to implementations.
2016-08-03 15:51:21 +00:00
profiler = gsk_renderer_get_profiler (renderer);
gsk: Make GskRenderer.render() drawing context-agnostic We're going to need to allow rendering on a specific cairo_t in order to implement fallback code paths inside GTK; this means that there will be times when we have a transient GskRenderer instance that does not have a GdkDrawingContext to draw on. Instead of adding a new render() implementation for those cases and then decide which one to use, we can remove the drawing context argument from the virtual function itself, and allow using a NULL GdkDrawingContext when calling gsk_renderer_render(). A later commit will add a generic function to create a transient GskRenderer with a cairo_t attached to it. Renderers inside GSK will have to check whether we have access to a GdkDrawingContext, in which case we're going to use it; or if we have access to a cairo_t and a window.
2016-08-24 15:21:50 +00:00
#endif
gsk: Add GskProfiler to GskRenderer The profiler instance is per-renderer, and is accesible to implementations.
2016-08-03 15:51:21 +00:00
Rework the GL renderer
2017-11-03 12:09:02 +00:00
if (self->gl_context == NULL)
{
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
GSK_RENDERER_NOTE (renderer, OPENGL, g_message ("No valid GL context associated to the renderer"));
Rework the GL renderer
2017-11-03 12:09:02 +00:00
return;
}
gl renderer: begin/end_frame around do_render This fixes rendering to a texture on intel hardware. The glClear calls would throw a GL_FRAMEBUFFER_INCOMPLETE error here, because the gsk_gl_driver_begin_frame() call in do_render() reset the framebuffer object in use.
2019-04-22 12:20:02 +00:00
g_assert (gsk_gl_driver_in_frame (self->gl_driver));
gsk: Drop modelview/projection from GskRenderer API The details of the modelview and projection matrices are only useful for the GL renderer; there's really no point in having those details available in the generic API — especially as the Cairo fallback renderer cannot really set up a complex modelview or a projection matrix.
2016-08-10 16:50:03 +00:00
/* Set up the modelview and projection matrices to fit our viewport */
graphene_matrix_init_scale (&modelview, scale_factor, scale_factor, 1.0);
graphene_matrix_init_ortho (&projection,
gsk: Implement gsk_renderer_render_texture() on GL
2016-12-22 19:01:52 +00:00
viewport->origin.x,
Rework the GL renderer
2017-11-03 12:09:02 +00:00
viewport->origin.x + viewport->size.width,
gsk: Implement gsk_renderer_render_texture() on GL
2016-12-22 19:01:52 +00:00
viewport->origin.y,
Rework the GL renderer
2017-11-03 12:09:02 +00:00
viewport->origin.y + viewport->size.height,
gsk: Drop modelview/projection from GskRenderer API The details of the modelview and projection matrices are only useful for the GL renderer; there's really no point in having those details available in the generic API — especially as the Cairo fallback renderer cannot really set up a complex modelview or a projection matrix.
2016-08-10 16:50:03 +00:00
ORTHO_NEAR_PLANE,
ORTHO_FAR_PLANE);
gl renderer: Properly flip texture in render_texture path Just do this on the CPU instead.
2017-12-28 10:03:33 +00:00
graphene_matrix_scale (&projection, 1, -1, 1);
gsk: Add GskGLDriver We can move the caching and management of textures, VAOs, and state of the GL machinery into a single object, GskGLDriver.
2016-07-08 15:21:13 +00:00
Share glyph and icon caches Use the same texture atlases to back both the glyph and icon caches, and unify their sizes and management. Store big glyphs in separate textures, so all atlases have the same size. Tweak some of the eviction parameters. We share the caches across all GL contexts on a display, unless the GSK_NO_SHARED_CACHES env var is set.
2019-06-04 21:27:09 +00:00
gsk_gl_texture_atlases_begin_frame (self->atlases);
gsk_gl_glyph_cache_begin_frame (self->glyph_cache);
gsk_gl_icon_cache_begin_frame (self->icon_cache);
gl renderer: Cache blurred outset shadow nodes Since these are particularly expensive to render and we have a pretty big one used in every client-side decorated window.
2018-07-08 18:08:15 +00:00
gsk_gl_shadow_cache_begin_frame (&self->shadow_cache, self->gl_driver);
gsk: Add GskProfiler to GskRenderer The profiler instance is per-renderer, and is accesible to implementations.
2016-08-03 15:51:21 +00:00
gl renderer: Keep op builder around GL keeps the unoform state per-program, but not per-frame. So, we can't pretend that this works for us. Keep the RenderOpBuilder around for the entire lifetime of the renderer instead.
2019-04-24 15:55:14 +00:00
ops_set_projection (&self->op_builder, &projection);
ops_set_viewport (&self->op_builder, viewport);
gl renderer: Use GskTransform in render ops builder for the modelview matrix. We need this later.
2019-06-02 07:55:11 +00:00
ops_set_modelview (&self->op_builder, gsk_transform_scale (NULL, scale_factor, scale_factor));
gl renderer: Add a clip stack So we can check that the currently set clip is the first one and now intersect with it. This first clip is always the entire viewport or the entire render_area and we don't want to end up drawing things to a texture because of it.
2018-12-30 14:25:01 +00:00
gl renderer: Set the render region as initial clip So we avoid creating render ops for things outside of it.
2018-12-02 05:56:52 +00:00
/* Initial clip is self->render_region! */
if (self->render_region != NULL)
{
gl renderer: Remove GskRoundedRect initializaion
2019-02-23 15:59:46 +00:00
graphene_rect_t transformed_render_region;
gl renderer: Remove debug code
2019-01-06 09:59:21 +00:00
cairo_rectangle_int_t render_extents;
gl renderer: Set the render region as initial clip So we avoid creating render ops for things outside of it.
2018-12-02 05:56:52 +00:00
cairo_region_get_extents (self->render_region, &render_extents);
gl renderer: Keep op builder around GL keeps the unoform state per-program, but not per-frame. So, we can't pretend that this works for us. Keep the RenderOpBuilder around for the entire lifetime of the renderer instead.
2019-04-24 15:55:14 +00:00
ops_transform_bounds_modelview (&self->op_builder,
gl renderer: Add a clip stack So we can check that the currently set clip is the first one and now intersect with it. This first clip is always the entire viewport or the entire render_area and we don't want to end up drawing things to a texture because of it.
2018-12-30 14:25:01 +00:00
&GRAPHENE_RECT_INIT (render_extents.x,
render_extents.y,
render_extents.width,
render_extents.height),
gl renderer: Remove GskRoundedRect initializaion
2019-02-23 15:59:46 +00:00
&transformed_render_region);
gl renderer: Keep op builder around GL keeps the unoform state per-program, but not per-frame. So, we can't pretend that this works for us. Keep the RenderOpBuilder around for the entire lifetime of the renderer instead.
2019-04-24 15:55:14 +00:00
ops_push_clip (&self->op_builder,
gl renderer: Remove GskRoundedRect initializaion
2019-02-23 15:59:46 +00:00
&GSK_ROUNDED_RECT_INIT (transformed_render_region.origin.x,
transformed_render_region.origin.y,
transformed_render_region.size.width,
transformed_render_region.size.height));
gl renderer: Set the render region as initial clip So we avoid creating render ops for things outside of it.
2018-12-02 05:56:52 +00:00
}
else
{
gl renderer: Keep op builder around GL keeps the unoform state per-program, but not per-frame. So, we can't pretend that this works for us. Keep the RenderOpBuilder around for the entire lifetime of the renderer instead.
2019-04-24 15:55:14 +00:00
ops_push_clip (&self->op_builder,
gl renderer: Add a clip stack So we can check that the currently set clip is the first one and now intersect with it. This first clip is always the entire viewport or the entire render_area and we don't want to end up drawing things to a texture because of it.
2018-12-30 14:25:01 +00:00
&GSK_ROUNDED_RECT_INIT (viewport->origin.x,
viewport->origin.y,
viewport->size.width,
viewport->size.height));
gl renderer: Set the render region as initial clip So we avoid creating render ops for things outside of it.
2018-12-02 05:56:52 +00:00
}
gl renderer: Insert render target op in render_texture path
2017-12-27 22:15:07 +00:00
gl renderer: Rename texture_id parameter to fbo_id So this makes sense again.
2018-04-21 08:13:16 +00:00
if (fbo_id != 0)
gl renderer: Keep op builder around GL keeps the unoform state per-program, but not per-frame. So, we can't pretend that this works for us. Keep the RenderOpBuilder around for the entire lifetime of the renderer instead.
2019-04-24 15:55:14 +00:00
ops_set_render_target (&self->op_builder, fbo_id);
gl renderer: Insert render target op in render_texture path
2017-12-27 22:15:07 +00:00
GskGLRenderer: Add debug groups This adds debug groups in various places, including the debug nodes if those are in use. This makes the traces in tools like renderdoc much easier to read.
2019-04-24 11:28:11 +00:00
gdk_gl_context_push_debug_group (self->gl_context, "Adding render ops");
gl renderer: Keep op builder around GL keeps the unoform state per-program, but not per-frame. So, we can't pretend that this works for us. Keep the RenderOpBuilder around for the entire lifetime of the renderer instead.
2019-04-24 15:55:14 +00:00
gsk_gl_renderer_add_render_ops (self, root, &self->op_builder);
GskGLRenderer: Add debug groups This adds debug groups in various places, including the debug nodes if those are in use. This makes the traces in tools like renderdoc much easier to read.
2019-04-24 11:28:11 +00:00
gdk_gl_context_pop_debug_group (self->gl_context);
gl renderer: Rework once more Last time, I swear.
2017-11-22 10:32:23 +00:00
gl renderer: Don't use texture ids in glBindFramebuffer calls
2018-04-12 09:02:46 +00:00
/* We correctly reset the state everywhere */
gl renderer: Keep op builder around GL keeps the unoform state per-program, but not per-frame. So, we can't pretend that this works for us. Keep the RenderOpBuilder around for the entire lifetime of the renderer instead.
2019-04-24 15:55:14 +00:00
g_assert_cmpint (self->op_builder.current_render_target, ==, fbo_id);
ops_pop_modelview (&self->op_builder);
ops_pop_clip (&self->op_builder);
buffer_size = self->op_builder.buffer_size;
ops_finish (&self->op_builder);
gl renderer: Don't use texture ids in glBindFramebuffer calls
2018-04-12 09:02:46 +00:00
gl renderer: Rework once more Last time, I swear.
2017-11-22 10:32:23 +00:00
/*g_message ("Ops: %u", self->render_ops->len);*/
/* Now actually draw things... */
gsk: Add GskProfiler to GskRenderer The profiler instance is per-renderer, and is accesible to implementations.
2016-08-03 15:51:21 +00:00
#ifdef G_ENABLE_DEBUG
gsk: Move resource handling inside GskGLDriver We want the GL driver to cache as many resources as possible, so we can always ensure that we're in a consistent state, and we can handle state transitions more appropriately.
2016-07-20 16:55:35 +00:00
gsk_gl_profiler_begin_gpu_region (self->gl_profiler);
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_profiler_timer_begin (profiler, self->profile_timers.cpu_time);
#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
gl renderer: bind the texture framebuffer before rendering When rendering to a texture, collecting the render ops might bind a different framebuffer, so bind the one we want again before doing the actual rendering.
2019-04-24 12:25:54 +00:00
/* Actually do the rendering */
if (fbo_id != 0)
glBindFramebuffer (GL_FRAMEBUFFER, fbo_id);
gl renderer: call glViewport directly
2018-06-10 12:41:43 +00:00
glViewport (0, 0, ceilf (viewport->size.width), ceilf (viewport->size.height));
gdkgl: Add gdk_gl_context_get_damage() This is a way to query the damaged area of the backbuffer. The GL renderer uses this to compute the extents of that damage region (computed via buffer age) and use them to minimize the area to redraw. This changes the semantics of GL rendering to "When calling gdk_window_begin_frame() with a GL context, the area by gdk_gl_context_get_damage() needs to be redrawn and every other pixel of the backbuffer is guaranteed to be correct. After gdk_window_end_frame() on a GL-drawn window, the whole backbuffer must be correct. We can always glXBufferSwap() now because of this.
2016-12-04 15:33:13 +00:00
gsk_gl_renderer_setup_render_mode (self);
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_gl_renderer_clear (self);
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: Simplify buffer handling in GskGLRenderer We don't have optional stencil and depth buffers, like GtkGLArea: we always create both of them internally.
2016-07-19 13:42:54 +00:00
glEnable (GL_DEPTH_TEST);
glDepthFunc (GL_LEQUAL);
gsk: Enable depth testing Use the appropriate depth testing function for transparent items.
2016-07-08 15:40:42 +00:00
Rework the GL renderer
2017-11-03 12:09:02 +00:00
/* Pre-multiplied alpha! */
gl renderer: Rework once more Last time, I swear.
2017-11-22 10:32:23 +00:00
glEnable (GL_BLEND);
gsk: Fix the blend mode The default blend mode should be the equivalent of Cairo's OVER operator.
2016-08-09 15:27:18 +00:00
glBlendFunc (GL_ONE, GL_ONE_MINUS_SRC_ALPHA);
Rework the GL renderer
2017-11-03 12:09:02 +00:00
glBlendEquation (GL_FUNC_ADD);
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
GskGLRenderer: Add debug groups This adds debug groups in various places, including the debug nodes if those are in use. This makes the traces in tools like renderdoc much easier to read.
2019-04-24 11:28:11 +00:00
gdk_gl_context_push_debug_group (self->gl_context, "Rendering ops");
gl renderer: Keep op builder around GL keeps the unoform state per-program, but not per-frame. So, we can't pretend that this works for us. Keep the RenderOpBuilder around for the entire lifetime of the renderer instead.
2019-04-24 15:55:14 +00:00
gsk_gl_renderer_render_ops (self, buffer_size);
GskGLRenderer: Add debug groups This adds debug groups in various places, including the debug nodes if those are in use. This makes the traces in tools like renderdoc much easier to read.
2019-04-24 11:28:11 +00:00
gdk_gl_context_pop_debug_group (self->gl_context);
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
#ifdef G_ENABLE_DEBUG
gsk_profiler_counter_inc (profiler, self->profile_counters.frames);
gsk: Add tracing to the gl renderer Emit the equivalent of the cpu-time counter in the inspector.
2018-05-19 19:25:17 +00:00
start_time = gsk_profiler_timer_get_start (profiler, self->profile_timers.cpu_time);
gsk: Add GskProfiler to GskRenderer The profiler instance is per-renderer, and is accesible to implementations.
2016-08-03 15:51:21 +00:00
cpu_time = gsk_profiler_timer_end (profiler, self->profile_timers.cpu_time);
gsk_profiler_timer_set (profiler, self->profile_timers.cpu_time, cpu_time);
gsk: Add GL profiler We can use the GL_ARB_timer_query extension (available since OpenGL 3.2, and part of the OpenGL specification since version 3.3) to query the time elapsed when drawing each frame. This allows us to gather timing information on our use of the GPU.
2016-07-12 13:50:48 +00:00
gpu_time = gsk_gl_profiler_end_gpu_region (self->gl_profiler);
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_profiler_timer_set (profiler, self->profile_timers.gpu_time, gpu_time);
gsk_profiler_push_samples (profiler);
gsk: Add tracing to the gl renderer Emit the equivalent of the cpu-time counter in the inspector.
2018-05-19 19:25:17 +00:00
if (gdk_profiler_is_running ())
gdk_profiler_add_mark (start_time, cpu_time, "render", "");
gsk: Add GskProfiler to GskRenderer The profiler instance is per-renderer, and is accesible to implementations.
2016-08-03 15:51:21 +00:00
#endif
gsk: Implement gsk_renderer_render_texture() on GL
2016-12-22 19:01:52 +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
static GdkTexture *
gsk: Implement gsk_renderer_render_texture() on GL
2016-12-22 19:01:52 +00:00
gsk_gl_renderer_render_texture (GskRenderer *renderer,
GskRenderNode *root,
const graphene_rect_t *viewport)
{
GskGLRenderer *self = GSK_GL_RENDERER (renderer);
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;
Rework the GL renderer
2017-11-03 12:09:02 +00:00
int width, height;
gl renderer: Use a gl texture in render_texture Get rid of the manual y flipping and cairo business. This keeps the gl unit tests working at least.
2018-02-03 18:35:25 +00:00
guint texture_id;
guint fbo_id;
gsk: Implement gsk_renderer_render_texture() on GL
2016-12-22 19:01:52 +00:00
g_return_val_if_fail (self->gl_context != NULL, NULL);
glrenderer: Ensure current context for debug stuff
2019-05-08 16:18:11 +00:00
gdk_gl_context_make_current (self->gl_context);
GskGLRenderer: Add debug groups This adds debug groups in various places, including the debug nodes if those are in use. This makes the traces in tools like renderdoc much easier to read.
2019-04-24 11:28:11 +00:00
gdk_gl_context_push_debug_group_printf (self->gl_context,
"Render %s<%p> to texture", root->node_class->type_name, root);
Rework the GL renderer
2017-11-03 12:09:02 +00:00
width = ceilf (viewport->size.width);
height = ceilf (viewport->size.height);
gsk: Implement gsk_renderer_render_texture() on GL
2016-12-22 19:01:52 +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
self->scale_factor = gdk_surface_get_scale_factor (gsk_renderer_get_surface (renderer));
gsk: Implement gsk_renderer_render_texture() on GL
2016-12-22 19:01:52 +00:00
Rework the GL renderer
2017-11-03 12:09:02 +00:00
/* Prepare our framebuffer */
gsk: Implement gsk_renderer_render_texture() on GL
2016-12-22 19:01:52 +00:00
gsk_gl_driver_begin_frame (self->gl_driver);
gl renderer: Use a gl texture in render_texture Get rid of the manual y flipping and cairo business. This keeps the gl unit tests working at least.
2018-02-03 18:35:25 +00:00
glGenTextures (1, &texture_id);
glBindTexture (GL_TEXTURE_2D, texture_id);
gl renderer: Properly flip texture in render_texture path Just do this on the CPU instead.
2017-12-28 10:03:33 +00:00
GskGLRenderer: Label various gl objects This means the names are more useful in tools like renderdoc.
2019-04-24 11:27:43 +00:00
gdk_gl_context_label_object_printf (self->gl_context, GL_TEXTURE, texture_id,
"Texture %s<%p> %d", root->node_class->type_name, root, texture_id);
gl renderer: Use a gl texture in render_texture Get rid of the manual y flipping and cairo business. This keeps the gl unit tests working at least.
2018-02-03 18:35:25 +00:00
if (gdk_gl_context_get_use_es (self->gl_context))
glTexImage2D (GL_TEXTURE_2D, 0, GL_RGBA8, width, height, 0, GL_RGBA, GL_UNSIGNED_BYTE, NULL);
else
glTexImage2D (GL_TEXTURE_2D, 0, GL_RGBA8, width, height, 0, GL_BGRA, GL_UNSIGNED_BYTE, NULL);
gsk: Implement gsk_renderer_render_texture() on GL
2016-12-22 19:01:52 +00:00
gl renderer: Use a gl texture in render_texture Get rid of the manual y flipping and cairo business. This keeps the gl unit tests working at least.
2018-02-03 18:35:25 +00:00
glGenFramebuffers (1, &fbo_id);
glBindFramebuffer (GL_FRAMEBUFFER, fbo_id);
GskGLRenderer: Label various gl objects This means the names are more useful in tools like renderdoc.
2019-04-24 11:27:43 +00:00
gdk_gl_context_label_object_printf (self->gl_context, GL_FRAMEBUFFER, fbo_id,
"FB %s<%p> %d", root->node_class->type_name, root, fbo_id);
gl renderer: Use a gl texture in render_texture Get rid of the manual y flipping and cairo business. This keeps the gl unit tests working at least.
2018-02-03 18:35:25 +00:00
glFramebufferTexture2D (GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, texture_id, 0);
gl renderer: Draw rounded clip child to a texture And then clip the texture using the current (maybe also rounded) clip. This way, the result is correct. We don't necessarily have to do the offscreen drawing in any case, but got the safe route for now.
2018-03-14 11:36:32 +00:00
g_assert_cmphex (glCheckFramebufferStatus (GL_FRAMEBUFFER), ==, GL_FRAMEBUFFER_COMPLETE);
Rework the GL renderer
2017-11-03 12:09:02 +00:00
gl renderer: Use a gl texture in render_texture Get rid of the manual y flipping and cairo business. This keeps the gl unit tests working at least.
2018-02-03 18:35:25 +00:00
/* Render the actual scene */
gl renderer: Don't use texture ids in glBindFramebuffer calls
2018-04-12 09:02:46 +00:00
gsk_gl_renderer_do_render (renderer, root, viewport, fbo_id, 1);
gl renderer: Properly flip texture in render_texture path Just do this on the CPU instead.
2017-12-28 10:03:33 +00:00
gdk: Split out GL texture Put GdkGLTexture into its own file and rename the API to gdk_gl_texture_foo() instead of gdk_texture_foo_for_gl(). Apart from naming, no actual code changes.
2018-03-05 13:38:38 +00:00
texture = gdk_gl_texture_new (self->gl_context,
texture_id,
width, height,
NULL, NULL);
gsk: Implement gsk_renderer_render_texture() on GL
2016-12-22 19:01:52 +00:00
gl renderer: Delete render_texture framebuffer
2019-05-20 09:08:50 +00:00
glDeleteFramebuffers (1, &fbo_id);
gl renderer: begin/end_frame around do_render This fixes rendering to a texture on intel hardware. The glClear calls would throw a GL_FRAMEBUFFER_INCOMPLETE error here, because the gsk_gl_driver_begin_frame() call in do_render() reset the framebuffer object in use.
2019-04-22 12:20:02 +00:00
gsk_gl_driver_end_frame (self->gl_driver);
GskGLRenderer: Add debug groups This adds debug groups in various places, including the debug nodes if those are in use. This makes the traces in tools like renderdoc much easier to read.
2019-04-24 11:28:11 +00:00
gdk_gl_context_pop_debug_group (self->gl_context);
gl renderer: Clear resources after render_texture This makes multiple consecutive render_texture calls on the same renderer work.
2018-02-03 12:24:55 +00:00
gsk_gl_renderer_clear_tree (self);
gsk: Implement gsk_renderer_render_texture() on GL
2016-12-22 19:01:52 +00:00
return texture;
}
static void
gsk: move begin/end_frame vfuncs into the renderers
2018-03-28 13:01:34 +00:00
gsk_gl_renderer_render (GskRenderer *renderer,
GskRenderNode *root,
const cairo_region_t *update_area)
gsk: Implement gsk_renderer_render_texture() on GL
2016-12-22 19:01:52 +00:00
{
GskGLRenderer *self = GSK_GL_RENDERER (renderer);
graphene_rect_t viewport;
gdk: Get rid of gdk_drawing_context_get_clip() Use the identical gdk_draw_context_get_frame_region() instead.
2018-04-20 22:58:53 +00:00
const cairo_region_t *damage;
gsk: move begin/end_frame vfuncs into the renderers
2018-03-28 13:01:34 +00:00
GdkRectangle whole_surface;
GdkSurface *surface;
gsk: Implement gsk_renderer_render_texture() on GL
2016-12-22 19:01:52 +00:00
if (self->gl_context == NULL)
return;
glrenderer: Ensure current context for debug stuff
2019-05-08 16:18:11 +00:00
gdk_gl_context_make_current (self->gl_context);
GskGLRenderer: Add debug groups This adds debug groups in various places, including the debug nodes if those are in use. This makes the traces in tools like renderdoc much easier to read.
2019-04-24 11:28:11 +00:00
gdk_gl_context_push_debug_group_printf (self->gl_context,
"Render root node %p", root);
gsk: move begin/end_frame vfuncs into the renderers
2018-03-28 13:01:34 +00:00
surface = gsk_renderer_get_surface (renderer);
whole_surface = (GdkRectangle) {
0, 0,
gdk_surface_get_width (surface) * self->scale_factor,
gdk_surface_get_height (surface) * self->scale_factor
};
gsk: Refactor damage computation for GL renderer Previously, we got the damage, then computed the changed area, then started a frame with that changed area. But starting a frame computes the damage for us. So now we start a frame, then get the damage area from that, then compute the change area.
2018-04-20 14:07:34 +00:00
gdk: Move begin/end_frame() functions As they require a draw context and the draw context is already bound to the surface, it makes much more sense and reduces abiguity by moving these APIs to the draw context. As a side effect, we simplify GdkSurface APIs to a point where GdkSurface now does not concern itself with drawing anymore at all, apart from being the object that creates draw contexts.
2018-04-23 15:28:55 +00:00
gdk_draw_context_begin_frame (GDK_DRAW_CONTEXT (self->gl_context),
gdk: Get rid of GdkDrawingContext All information is kept in GdkDrawContext these days, so use that one.
2018-04-20 23:22:19 +00:00
update_area);
gsk: Refactor damage computation for GL renderer Previously, we got the damage, then computed the changed area, then started a frame with that changed area. But starting a frame computes the damage for us. So now we start a frame, then get the damage area from that, then compute the change area.
2018-04-20 14:07:34 +00:00
gdk: Get rid of gdk_drawing_context_get_clip() Use the identical gdk_draw_context_get_frame_region() instead.
2018-04-20 22:58:53 +00:00
damage = gdk_draw_context_get_frame_region (GDK_DRAW_CONTEXT (self->gl_context));
gsk: move begin/end_frame vfuncs into the renderers
2018-03-28 13:01:34 +00:00
if (cairo_region_contains_rectangle (damage, &whole_surface) == CAIRO_REGION_OVERLAP_IN)
{
self->render_region = NULL;
}
else
{
GdkRectangle extents;
cairo_region_get_extents (damage, &extents);
if (gdk_rectangle_equal (&extents, &whole_surface))
self->render_region = NULL;
else
gdk: Get rid of gdk_drawing_context_get_clip() Use the identical gdk_draw_context_get_frame_region() instead.
2018-04-20 22:58:53 +00:00
self->render_region = cairo_region_create_rectangle (&extents);
gsk: move begin/end_frame vfuncs into the renderers
2018-03-28 13:01:34 +00:00
}
gl renderer: Rename everything called window to surface
2018-03-26 19:13:52 +00:00
self->scale_factor = gdk_surface_get_scale_factor (surface);
gsk: Implement gsk_renderer_render_texture() on GL
2016-12-22 19:01:52 +00:00
gdk_gl_context_make_current (self->gl_context);
Rework the GL renderer
2017-11-03 12:09:02 +00:00
viewport.origin.x = 0;
viewport.origin.y = 0;
gl renderer: Rename everything called window to surface
2018-03-26 19:13:52 +00:00
viewport.size.width = gdk_surface_get_width (surface) * self->scale_factor;
viewport.size.height = gdk_surface_get_height (surface) * self->scale_factor;
gsk: Implement gsk_renderer_render_texture() on GL
2016-12-22 19:01:52 +00:00
gl renderer: begin/end_frame around do_render This fixes rendering to a texture on intel hardware. The glClear calls would throw a GL_FRAMEBUFFER_INCOMPLETE error here, because the gsk_gl_driver_begin_frame() call in do_render() reset the framebuffer object in use.
2019-04-22 12:20:02 +00:00
gsk_gl_driver_begin_frame (self->gl_driver);
gl renderer: Use a gl texture in render_texture Get rid of the manual y flipping and cairo business. This keeps the gl unit tests working at least.
2018-02-03 18:35:25 +00:00
gsk_gl_renderer_do_render (renderer, root, &viewport, 0, self->scale_factor);
gl renderer: begin/end_frame around do_render This fixes rendering to a texture on intel hardware. The glClear calls would throw a GL_FRAMEBUFFER_INCOMPLETE error here, because the gsk_gl_driver_begin_frame() call in do_render() reset the framebuffer object in use.
2019-04-22 12:20:02 +00:00
gsk_gl_driver_end_frame (self->gl_driver);
gsk: Add GL profiler We can use the GL_ARB_timer_query extension (available since OpenGL 3.2, and part of the OpenGL specification since version 3.3) to query the time elapsed when drawing each frame. This allows us to gather timing information on our use of the GPU.
2016-07-12 13:50:48 +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
gsk_gl_renderer_clear_tree (self);
gsk: move begin/end_frame vfuncs into the renderers
2018-03-28 13:01:34 +00:00
gdk: Move begin/end_frame() functions As they require a draw context and the draw context is already bound to the surface, it makes much more sense and reduces abiguity by moving these APIs to the draw context. As a side effect, we simplify GdkSurface APIs to a point where GdkSurface now does not concern itself with drawing anymore at all, apart from being the object that creates draw contexts.
2018-04-23 15:28:55 +00:00
gdk_draw_context_end_frame (GDK_DRAW_CONTEXT (self->gl_context));
gl renderer: Really fix gl debugging code Properly label an object and make sure we have the right gl context even after a gdk_gl_context_end_frame call.
2019-05-20 06:47:41 +00:00
gdk_gl_context_make_current (self->gl_context);
gsk: move begin/end_frame vfuncs into the renderers
2018-03-28 13:01:34 +00:00
GskGLRenderer: Add debug groups This adds debug groups in various places, including the debug nodes if those are in use. This makes the traces in tools like renderdoc much easier to read.
2019-04-24 11:28:11 +00:00
gdk_gl_context_pop_debug_group (self->gl_context);
gsk: move begin/end_frame vfuncs into the renderers
2018-03-28 13:01:34 +00:00
g_clear_pointer (&self->render_region, cairo_region_destroy);
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_gl_renderer_class_init (GskGLRendererClass *klass)
{
GObjectClass *gobject_class = G_OBJECT_CLASS (klass);
GskRendererClass *renderer_class = GSK_RENDERER_CLASS (klass);
gobject_class->dispose = gsk_gl_renderer_dispose;
renderer_class->realize = gsk_gl_renderer_realize;
renderer_class->unrealize = gsk_gl_renderer_unrealize;
renderer_class->render = gsk_gl_renderer_render;
gsk: Implement gsk_renderer_render_texture() on GL
2016-12-22 19:01:52 +00:00
renderer_class->render_texture = gsk_gl_renderer_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
}
static void
gsk_gl_renderer_init (GskGLRenderer *self)
{
gsk_ensure_resources ();
gl renderer: Don't zero initialize render ops GArray
2017-12-05 17:05:12 +00:00
self->render_ops = g_array_new (FALSE, FALSE, sizeof (RenderOp));
glrenderer: Reuse the GArray for render items
2017-03-29 16:45:51 +00:00
gl renderer: Keep op builder around GL keeps the unoform state per-program, but not per-frame. So, we can't pretend that this works for us. Keep the RenderOpBuilder around for the entire lifetime of the renderer instead.
2019-04-24 15:55:14 +00:00
ops_init (&self->op_builder);
self->op_builder.renderer = self;
self->op_builder.render_ops = self->render_ops;
gsk: Add GskProfiler to GskRenderer The profiler instance is per-renderer, and is accesible to implementations.
2016-08-03 15:51:21 +00:00
#ifdef G_ENABLE_DEBUG
{
GskProfiler *profiler = gsk_renderer_get_profiler (GSK_RENDERER (self));
self->profile_counters.frames = gsk_profiler_add_counter (profiler, "frames", "Frames", FALSE);
self->profile_counters.draw_calls = gsk_profiler_add_counter (profiler, "draws", "glDrawArrays", TRUE);
self->profile_timers.cpu_time = gsk_profiler_add_timer (profiler, "cpu-time", "CPU time", FALSE, TRUE);
self->profile_timers.gpu_time = gsk_profiler_add_timer (profiler, "gpu-time", "GPU time", FALSE, TRUE);
}
#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: Export gsk_gl_renderer_new()
2019-05-02 00:13:16 +00:00
/**
* gsk_gl_renderer_new:
*
* Creates a new #GskRenderer using OpenGL. This is the default renderer
* used by GTK.
*
* Returns: a new GL renderer
**/
GskRenderer *
gsk_gl_renderer_new (void)
{
return g_object_new (GSK_TYPE_GL_RENDERER, NULL);
}
Reference in New Issue Copy Permalink