AuroraMiddleware/gtk2
1
0
Fork 0
forked from AuroraMiddleware/gtk
Code Issues Pull Requests Projects Releases Wiki Activity
4abbf929ad
gtk2/gsk/gl/gskglrenderer.c

2599 lines
85 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"
#include "gskglrendererprivate.h"
#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"
#include "gskrendernodeprivate.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"
GskTexture => GdkTexture We want this thing to replace GdkPixbuf, so it has to live in GDK.
2017-11-02 20:39:00 +00:00
#include "gdk/gdktextureprivate.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"
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"
#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
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: 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: 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
get_gl_scaling_filters (GskRenderNode *node,
int *min_filter_r,
int *mag_filter_r)
{
*min_filter_r = GL_LINEAR;
*mag_filter_r = GL_LINEAR;
}
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;
graphene_vec4_t id_row3;
if (graphene_vec4_get_w (offset) != 0.0f)
return TRUE;
graphene_vec4_init (&id_row3, 0, 0, 0, 1);
graphene_matrix_get_row (matrix, 3, &row3);
return !graphene_vec4_equal (&id_row3, &row3);
}
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: 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: Factor out a helper function for offscreen drawing
2017-11-24 09:18:51 +00:00
RenderOpBuilder *builder,
float min_x,
float max_x,
float min_y,
float max_y,
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
GskRenderNode *child_node,
int *texture_id,
gl renderer: Force cross-fade nodes offscreen
2017-12-19 11:45:32 +00:00
gboolean *is_offscreen,
gboolean force_offscreen);
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);
gl renderer: Rework once more Last time, I swear.
2017-11-22 10:32:23 +00:00
typedef enum
{
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
RENDER_FULL,
RENDER_SCISSOR
} RenderMode;
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;
graphene_rect_t viewport;
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: Implement gsk_renderer_render_texture() on GL
2016-12-22 19:01:52 +00:00
guint texture_id;
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: 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: 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 blend_program;
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: Implement simple shadow nodes
2017-12-01 09:27:31 +00:00
Program 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: 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
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
gl: Add glyph cache Based on the one used by the vulkan renderer
2017-11-18 13:30:57 +00:00
GskGLGlyphCache glyph_cache;
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
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
RenderMode render_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
gboolean has_buffers : 1;
};
struct _GskGLRendererClass
{
GskRendererClass parent_class;
};
G_DEFINE_TYPE (GskGLRenderer, gsk_gl_renderer, GSK_TYPE_RENDERER)
gl renderer: Handle borders in hidpi better
2017-12-09 07:57:13 +00:00
static inline void
rounded_rect_intersect (GskGLRenderer *self,
RenderOpBuilder *builder,
const GskRoundedRect *rect,
GskRoundedRect *dest)
{
graphene_rect_t transformed_rect;
graphene_rect_t intersection;
int i;
graphene_matrix_transform_bounds (&builder->current_modelview, &rect->bounds, &transformed_rect);
graphene_rect_intersection (&transformed_rect, &builder->current_clip.bounds,
&intersection);
dest->bounds = intersection;
for (i = 0; i < 4; i ++)
{
dest->corner[i].width = rect->corner[i].width * self->scale_factor;
dest->corner[i].height = rect->corner[i].height * self->scale_factor;
}
}
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)
{
int i;
graphene_rect_t transformed_bounds;
graphene_matrix_transform_bounds (&builder->current_modelview, &rect->bounds, &transformed_bounds);
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 ++)
{
corner_widths[i] = rect->corner[i].width * self->scale_factor;
corner_heights[i] = rect->corner[i].height * self->scale_factor;
}
}
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,
RenderOpBuilder *builder,
const GskQuadVertex *vertex_data)
{
cairo_surface_t *surface;
cairo_t *cr;
int texture_id;
surface = cairo_image_surface_create (CAIRO_FORMAT_ARGB32,
ceilf (node->bounds.size.width) * self->scale_factor,
ceilf (node->bounds.size.height) * self->scale_factor);
cairo_surface_set_device_scale (surface, self->scale_factor, self->scale_factor);
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);
#if HIGHLIGHT_FALLBACK
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);
#endif
cairo_destroy (cr);
/* Upload the Cairo surface to a GL texture */
texture_id = gsk_gl_driver_create_texture (self->gl_driver,
node->bounds.size.width * self->scale_factor,
node->bounds.size.height * self->scale_factor);
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);
cairo_surface_destroy (surface);
ops_set_program (builder, &self->blit_program);
ops_set_texture (builder, texture_id);
ops_draw (builder, vertex_data);
}
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);
guint num_glyphs = gsk_text_node_get_num_glyphs (node);
int i;
int x_position = 0;
gl renderer: Fix shadow nodes if the child is a container
2017-12-09 17:26:29 +00:00
int x = gsk_text_node_get_x (node) + builder->dx;
int y = gsk_text_node_get_y (node) + 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];
const GskGLCachedGlyph *glyph;
int glyph_x, glyph_y, glyph_w, glyph_h;
float tx, ty, tx2, ty2;
double cx;
double cy;
if (gi->glyph == PANGO_GLYPH_EMPTY ||
(gi->glyph & PANGO_GLYPH_UNKNOWN_FLAG) > 0)
continue;
glyph = gsk_gl_glyph_cache_lookup (&self->glyph_cache,
TRUE,
(PangoFont *)font,
gi->glyph,
self->scale_factor);
/* e.g. whitespace */
if (glyph->draw_width <= 0 || glyph->draw_height <= 0)
{
x_position += gi->geometry.width;
continue;
}
cx = (double)(x_position + gi->geometry.x_offset) / PANGO_SCALE;
cy = (double)(gi->geometry.y_offset) / PANGO_SCALE;
ops_set_texture (builder, gsk_gl_glyph_cache_get_glyph_image (&self->glyph_cache,
glyph)->texture_id);
gl renderer: Move declarations to the beginning of the block
2017-12-09 15:21:19 +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
gl renderer: Move declarations to the beginning of the block
2017-12-09 15:21:19 +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: Move declarations to the beginning of the block
2017-12-09 15:21:19 +00:00
{
const GskQuadVertex vertex_data[GL_N_VERTICES] = {
gl renderer: Split out text rendering function We'll use that for text shadow nodes
2017-12-01 09:47:13 +00:00
{ { glyph_x, glyph_y }, { tx, ty }, },
{ { glyph_x, glyph_y + glyph_h }, { tx, ty2 }, },
{ { glyph_x + glyph_w, glyph_y }, { tx2, ty }, },
{ { 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 }, },
};
ops_draw (builder, vertex_data);
}
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: Try to fix border rendering
2017-12-08 16:01:16 +00:00
const float min_x = node->bounds.origin.x;
const float min_y = 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: 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);
float widths[4];
gl renderer: Implement simple border nodes
2017-12-01 10:55:10 +00:00
const gboolean needs_clip = TRUE;/*!gsk_rounded_rect_is_rectilinear (rounded_outline);*/
gl renderer: Handle borders in hidpi better
2017-12-09 07:57:13 +00:00
int i;
gl renderer: Implement simple border nodes
2017-12-01 10:55:10 +00:00
GskRoundedRect prev_clip;
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 ++)
widths[i] *= self->scale_factor;
gl renderer: Implement simple border nodes
2017-12-01 10:55:10 +00:00
if (needs_clip)
{
gl renderer: Handle borders in hidpi better
2017-12-09 07:57:13 +00:00
GskRoundedRect child_clip;
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
ops_set_program (builder, &self->border_program);
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
rounded_rect_intersect (self, builder, rounded_outline, &child_clip);
gl renderer: Implement simple border nodes
2017-12-01 10:55:10 +00:00
prev_clip = ops_set_clip (builder, &child_clip);
gl renderer: Keep track of border program state
2017-12-05 07:38:42 +00:00
ops_set_border (builder, widths);
gl renderer: Implement simple border nodes
2017-12-01 10:55:10 +00:00
}
else
{
ops_set_program (builder, &self->color_program);
}
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 };
int i;
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: 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
if (needs_clip)
ops_set_clip (builder, &prev_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
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);
}
static inline void
render_texture_node (GskGLRenderer *self,
GskRenderNode *node,
RenderOpBuilder *builder,
const GskQuadVertex *vertex_data)
{
GdkTexture *texture = gsk_texture_node_get_texture (node);
int gl_min_filter = GL_NEAREST, gl_mag_filter = GL_NEAREST;
int texture_id;
get_gl_scaling_filters (node, &gl_min_filter, &gl_mag_filter);
texture_id = gsk_gl_driver_get_texture_for_texture (self->gl_driver,
texture,
gl_min_filter,
gl_mag_filter);
ops_set_program (builder, &self->blit_program);
ops_set_texture (builder, texture_id);
ops_draw (builder, vertex_data);
}
static inline void
render_cairo_node (GskGLRenderer *self,
GskRenderNode *node,
RenderOpBuilder *builder,
const GskQuadVertex *vertex_data)
{
const cairo_surface_t *surface = gsk_cairo_node_peek_surface (node);
int gl_min_filter = GL_NEAREST, gl_mag_filter = GL_NEAREST;
int texture_id;
if (surface == NULL)
return;
get_gl_scaling_filters (node, &gl_min_filter, &gl_mag_filter);
texture_id = gsk_gl_driver_create_texture (self->gl_driver,
gl renderer: Fix cairo node surface size in hidpi
2017-12-09 08:25:47 +00:00
node->bounds.size.width * self->scale_factor,
node->bounds.size.height * self->scale_factor);
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_driver_bind_source_texture (self->gl_driver, texture_id);
gsk_gl_driver_init_texture_with_surface (self->gl_driver,
texture_id,
(cairo_surface_t *)surface,
gl_min_filter,
gl_mag_filter);
ops_set_program (builder, &self->blit_program);
ops_set_texture (builder, texture_id);
ops_draw (builder, vertex_data);
}
static inline void
render_transform_node (GskGLRenderer *self,
GskRenderNode *node,
RenderOpBuilder *builder)
{
GskRenderNode *child = gsk_transform_node_get_child (node);
graphene_matrix_t prev_mv;
graphene_matrix_t transform, transformed_mv;
graphene_matrix_init_from_matrix (&transform, gsk_transform_node_peek_transform (node));
graphene_matrix_multiply (&transform, &builder->current_modelview, &transformed_mv);
prev_mv = ops_set_modelview (builder, &transformed_mv);
gsk_gl_renderer_add_render_ops (self, child, builder);
ops_set_modelview (builder, &prev_mv);
}
static inline void
render_opacity_node (GskGLRenderer *self,
GskRenderNode *node,
RenderOpBuilder *builder)
{
float prev_opacity;
prev_opacity = ops_set_opacity (builder,
builder->current_opacity * gsk_opacity_node_get_opacity (node));
gsk_gl_renderer_add_render_ops (self, gsk_opacity_node_get_child (node), builder);
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;
op.linear_gradient.end_point = *end;
ops_add (builder, &op);
ops_draw (builder, vertex_data);
}
static inline void
render_clip_node (GskGLRenderer *self,
GskRenderNode *node,
RenderOpBuilder *builder)
{
GskRoundedRect prev_clip;
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);
graphene_matrix_transform_bounds (&builder->current_modelview, &transformed_clip, &transformed_clip);
graphene_rect_intersection (&transformed_clip,
&builder->current_clip.bounds,
&intersection);
gsk_rounded_rect_init_from_rect (&child_clip, &intersection, 0.0f);
prev_clip = ops_set_clip (builder, &child_clip);
gsk_gl_renderer_add_render_ops (self, child, builder);
ops_set_clip (builder, &prev_clip);
}
static inline void
render_rounded_clip_node (GskGLRenderer *self,
GskRenderNode *node,
RenderOpBuilder *builder)
{
GskRoundedRect prev_clip;
GskRenderNode *child = gsk_rounded_clip_node_get_child (node);
const GskRoundedRect *rounded_clip = gsk_rounded_clip_node_peek_clip (node);
GskRoundedRect child_clip;
gl renderer: Fix rounded clips in hidpi
2017-12-09 07:59:51 +00:00
rounded_rect_intersect (self, builder, rounded_clip, &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
prev_clip = ops_set_clip (builder, &child_clip);
gsk_gl_renderer_add_render_ops (self, child, builder);
ops_set_clip (builder, &prev_clip);
}
static inline void
render_color_matrix_node (GskGLRenderer *self,
GskRenderNode *node,
RenderOpBuilder *builder,
const GskQuadVertex *vertex_data)
{
const float min_x = node->bounds.origin.x;
const float min_y = node->bounds.origin.y;
const float max_x = min_x + node->bounds.size.width;
const float max_y = min_y + node->bounds.size.height;
int texture_id;
gboolean is_offscreen;
add_offscreen_ops (self, builder, min_x, max_x, min_y, max_y,
gsk_color_matrix_node_get_child (node),
gl renderer: Force cross-fade nodes offscreen
2017-12-19 11:45:32 +00:00
&texture_id, &is_offscreen, FALSE);
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));
ops_set_texture (builder, texture_id);
if (is_offscreen)
{
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 }, },
};
ops_draw (builder, vertex_data);
}
else
{
ops_draw (builder, vertex_data);
}
}
static inline void
render_blur_node (GskGLRenderer *self,
GskRenderNode *node,
RenderOpBuilder *builder,
const GskQuadVertex *vertex_data)
{
const float min_x = node->bounds.origin.x;
const float min_y = node->bounds.origin.y;
const float max_x = min_x + node->bounds.size.width;
const float max_y = min_y + node->bounds.size.height;
int texture_id;
gboolean is_offscreen;
RenderOp op;
add_offscreen_ops (self, builder, min_x, max_x, min_y, max_y,
gsk_blur_node_get_child (node),
gl renderer: Force cross-fade nodes offscreen
2017-12-19 11:45:32 +00:00
&texture_id, &is_offscreen, FALSE);
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);
op.blur.radius = gsk_blur_node_get_radius (node);
ops_add (builder, &op);
ops_set_texture (builder, texture_id);
if (is_offscreen)
{
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 }, },
};
ops_draw (builder, vertex_data);
}
else
{
ops_draw (builder, vertex_data);
}
}
static inline void
render_inset_shadow_node (GskGLRenderer *self,
GskRenderNode *node,
RenderOpBuilder *builder,
const GskQuadVertex *vertex_data)
{
RenderOp op;
/* TODO: Implement blurred inset shadows as well */
if (gsk_inset_shadow_node_get_blur_radius (node) > 0)
{
render_fallback_node (self, node, builder, vertex_data);
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: Fix inset and outset shadows in hidpi
2017-12-09 08:41:52 +00:00
op.inset_shadow.radius = gsk_inset_shadow_node_get_blur_radius (node) * self->scale_factor;
op.inset_shadow.spread = gsk_inset_shadow_node_get_spread (node) * self->scale_factor;
op.inset_shadow.offset[0] = gsk_inset_shadow_node_get_dx (node) * self->scale_factor;
op.inset_shadow.offset[1] = -gsk_inset_shadow_node_get_dy (node) * self->scale_factor;
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);
}
static inline void
render_outset_shadow_node (GskGLRenderer *self,
GskRenderNode *node,
RenderOpBuilder *builder,
const GskQuadVertex *vertex_data)
{
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: draw all outset shadows Instead of falling back to cairo for most of them.
2017-12-28 15:41:32 +00:00
const float min_x = outline->bounds.origin.x - spread - blur_extra / 2.0;
const float min_y = outline->bounds.origin.y - spread - blur_extra / 2.0;
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_matrix_t prev_modelview;
graphene_rect_t prev_viewport;
graphene_matrix_t item_proj;
GskRoundedRect prev_clip, blit_clip;
int prev_render_target;
int texture_id, render_target;
int blurred_texture_id, blurred_render_target;
/* 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
texture_id = gsk_gl_driver_create_texture (self->gl_driver, texture_width, texture_height);
gsk_gl_driver_bind_source_texture (self->gl_driver, texture_id);
gsk_gl_driver_init_texture_empty (self->gl_driver, texture_id);
render_target = gsk_gl_driver_create_render_target (self->gl_driver, texture_id, FALSE, FALSE);
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);
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
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);
prev_modelview = ops_set_modelview (builder, &identity);
prev_viewport = ops_set_viewport (builder, &GRAPHENE_RECT_INIT (0, 0, texture_width, texture_height));
/* Draw outline */
ops_set_program (builder, &self->color_program);
prev_clip = ops_set_clip (builder, &offset_outline);
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 }, },
{ { texture_width, texture_height }, { 1, 0 }, },
{ { 0, texture_height }, { 0, 0 }, },
{ { texture_width, }, { 1, 1 }, },
});
blurred_texture_id = gsk_gl_driver_create_texture (self->gl_driver, texture_width, texture_height);
gsk_gl_driver_bind_source_texture (self->gl_driver, blurred_texture_id);
gsk_gl_driver_init_texture_empty (self->gl_driver, blurred_texture_id);
blurred_render_target = gsk_gl_driver_create_render_target (self->gl_driver, blurred_texture_id, TRUE, TRUE);
ops_set_render_target (builder, blurred_render_target);
op.op = OP_CLEAR;
ops_add (builder, &op);
gsk_rounded_rect_init_from_rect (&blit_clip,
&GRAPHENE_RECT_INIT (0, 0, texture_width, texture_height), 0.0f);
if (blur_radius > 0)
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->blur_program);
gl renderer: draw all outset shadows Instead of falling back to cairo for most of them.
2017-12-28 15:41:32 +00:00
ops_set_clip (builder, &blit_clip);
ops_set_texture (builder, texture_id);
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_BLUR;
gl renderer: draw all outset shadows Instead of falling back to cairo for most of them.
2017-12-28 15:41:32 +00:00
op.blur.dir[0] = 1;
op.blur.dir[1] = 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
op.blur.size.width = texture_width;
op.blur.size.height = texture_height;
op.blur.radius = blur_radius;
ops_add (builder, &op);
gl renderer: draw all outset shadows Instead of falling back to cairo for most of them.
2017-12-28 15:41:32 +00:00
ops_draw (builder, (GskQuadVertex[GL_N_VERTICES]) {
{ { 0, 0 }, { 0, 1 }, },
{ { 0, texture_height }, { 0, 0 }, },
{ { texture_width, 0 }, { 1, 1 }, },
{ { texture_width, texture_height }, { 1, 0 }, },
{ { 0, texture_height }, { 0, 0 }, },
{ { texture_width, 0 }, { 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: try doing outset box shadows Still fall back in cases we can't handle that way.
2017-12-21 17:09:32 +00:00
else
{
ops_set_program (builder, &self->blit_program);
gl renderer: draw all outset shadows Instead of falling back to cairo for most of them.
2017-12-28 15:41:32 +00:00
ops_set_clip (builder, &blit_clip);
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 }, },
{ { texture_width, texture_height }, { 1, 0 }, },
{ { 0, texture_height }, { 0, 0 }, },
{ { texture_width, 0 }, { 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
}
ops_set_clip (builder, &prev_clip);
ops_set_viewport (builder, &prev_viewport);
ops_set_modelview (builder, &prev_modelview);
ops_set_projection (builder, &prev_projection);
ops_set_render_target (builder, prev_render_target);
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: draw all outset shadows Instead of falling back to cairo for most of them.
2017-12-28 15:41:32 +00:00
{
GskRoundedRect offset_outline = *outline;
graphene_matrix_transform_bounds (&builder->current_modelview, &outline->bounds, &offset_outline.bounds);
rounded_rect_to_floats (self, builder,
/*outline,*/
&offset_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
}
ops_set_clip (builder, &prev_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
}
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)
{
render_fallback_node (self, node, builder, vertex_data);
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;
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
int texture_id;
gboolean is_offscreen;
gl renderer: Fix shadow nodes if the child is a container
2017-12-09 17:26:29 +00:00
float prev_dx;
float prev_dy;
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);
gl renderer: Fix shadow nodes if the child is a container
2017-12-09 17:26:29 +00:00
min_x = shadow_child->bounds.origin.x;
min_y = shadow_child->bounds.origin.y;
max_x = min_x + shadow_child->bounds.size.width;
max_y = min_y + shadow_child->bounds.size.height;
prev_dx = builder->dx;
prev_dy = builder->dy;
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
if (gsk_render_node_get_node_type (shadow_child) == GSK_TEXT_NODE)
{
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);
ops_offset (builder, prev_dx, prev_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;
}
add_offscreen_ops (self, builder,
dx + min_x, dx + max_x, dy + min_y, dy + max_y,
gl renderer: Force cross-fade nodes offscreen
2017-12-19 11:45:32 +00:00
shadow_child, &texture_id, &is_offscreen, FALSE);
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 shadow nodes if the child is a container
2017-12-09 17:26:29 +00:00
ops_offset (builder, prev_dx, prev_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_set_program (builder, &self->shadow_program);
ops_set_color (builder, &shadow->color);
ops_set_texture (builder, texture_id);
if (is_offscreen)
{
const GskQuadVertex vertex_data[GL_N_VERTICES] = {
{ { dx + min_x, dy + min_y }, { 0, 1 }, },
{ { dx + min_x, dy + max_y }, { 0, 0 }, },
{ { dx + max_x, dy + min_y }, { 1, 1 }, },
{ { dx + max_x, dy + max_y }, { 1, 0 }, },
{ { dx + min_x, dy + max_y }, { 0, 0 }, },
{ { dx + max_x, dy + min_y }, { 1, 1 }, },
};
gl renderer: Fix shadow nodes if the child is a container
2017-12-09 17:26:29 +00:00
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
}
else
{
const GskQuadVertex vertex_data[GL_N_VERTICES] = {
{ { dx + min_x, dy + min_y }, { 0, 0 }, },
{ { dx + min_x, dy + max_y }, { 0, 1 }, },
{ { dx + max_x, dy + min_y }, { 1, 0 }, },
{ { dx + max_x, dy + max_y }, { 1, 1 }, },
{ { dx + min_x, dy + max_y }, { 0, 1 }, },
{ { dx + max_x, dy + min_y }, { 1, 0 }, },
};
ops_draw (builder, vertex_data);
}
}
/* 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)
{
const float min_x = node->bounds.origin.x;
const float min_y = node->bounds.origin.y;
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);
int start_texture_id;
int end_texture_id;
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. */
add_offscreen_ops (self, builder, min_x, max_x, min_y, max_y, start_node,
gl renderer: Force cross-fade nodes offscreen
2017-12-19 11:45:32 +00:00
&start_texture_id, &is_offscreen1, TRUE);
gl renderer: Implement cross fade nodes
2017-12-11 07:22:28 +00:00
add_offscreen_ops (self, builder, min_x, max_x, min_y, max_y, end_node,
gl renderer: Force cross-fade nodes offscreen
2017-12-19 11:45:32 +00:00
&end_texture_id, &is_offscreen2, TRUE);
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;
op.cross_fade.source2 = end_texture_id;
ops_add (builder, &op);
ops_set_texture (builder, start_texture_id);
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);
/* TODO: We use color.color_location here and this is right for all three of the programs above,
* but that's just a coincidence. */
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);
}
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)
{
OP_PRINT (" -> Border (%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);
}
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);
}
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);
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);
}
static void
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
gsk_gl_renderer_create_buffers (GskGLRenderer *self,
int width,
gsk: Take into account the scaling factor We need to apply a scaling factor whenever we deal with user-supplied coordinates, like: - when creating textures - when setting up the viewport - when submitting the scene
2016-07-27 15:48:35 +00:00
int height,
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
{
if (self->has_buffers)
return;
gsk: Take into account the scaling factor We need to apply a scaling factor whenever we deal with user-supplied coordinates, like: - when creating textures - when setting up the viewport - when submitting the scene
2016-07-27 15:48:35 +00:00
GSK_NOTE (OPENGL, g_print ("Creating buffers (w:%d, h:%d, scale:%d)\n", width, height, 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
gsk: Implement gsk_renderer_render_texture() on GL
2016-12-22 19:01:52 +00:00
if (self->texture_id == 0)
{
self->texture_id = gsk_gl_driver_create_texture (self->gl_driver,
width * scale_factor,
height * scale_factor);
gsk_gl_driver_bind_source_texture (self->gl_driver, self->texture_id);
gsk_gl_driver_init_texture_empty (self->gl_driver, self->texture_id);
}
gsk_gl_driver_create_render_target (self->gl_driver, self->texture_id, TRUE, TRUE);
Rework the GL renderer
2017-11-03 12:09:02 +00:00
gsk_gl_driver_bind_render_target (self->gl_driver, self->texture_id);
gsk: Implement gsk_renderer_render_texture() on GL
2016-12-22 19:01:52 +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
self->has_buffers = 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
}
static void
gsk_gl_renderer_destroy_buffers (GskGLRenderer *self)
{
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;
if (!self->has_buffers)
return;
GSK_NOTE (OPENGL, g_print ("Destroying buffers\n"));
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: Implement gsk_renderer_render_texture() on GL
2016-12-22 19:01:52 +00:00
if (self->texture_id != 0)
{
gsk_gl_driver_destroy_texture (self->gl_driver, self->texture_id);
self->texture_id = 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
self->has_buffers = FALSE;
}
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;
static struct {
const char *name;
const char *vs;
const char *fs;
} program_definitions[] = {
gl renderer: Implement simple border nodes
2017-12-01 10:55:10 +00:00
{ "blend", "blend.vs.glsl", "blend.fs.glsl" },
{ "blit", "blit.vs.glsl", "blit.fs.glsl" },
{ "color", "blit.vs.glsl", "color.fs.glsl" },
{ "coloring", "blit.vs.glsl", "coloring.fs.glsl" },
{ "color matrix", "blit.vs.glsl", "color_matrix.fs.glsl" },
{ "linear gradient", "blit.vs.glsl", "linear_gradient.fs.glsl" },
{ "blur", "blit.vs.glsl", "blur.fs.glsl" },
{ "inset shadow", "blit.vs.glsl", "inset_shadow.fs.glsl" },
{ "outset shadow", "blit.vs.glsl", "outset_shadow.fs.glsl" },
{ "shadow", "blit.vs.glsl", "shadow.fs.glsl" },
{ "border", "blit.vs.glsl", "border.fs.glsl" },
gl renderer: Implement cross fade nodes
2017-12-11 07:22:28 +00:00
{ "cross fade", "blit.vs.glsl", "cross_fade.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
if (GSK_RENDER_MODE_CHECK (SHADERS))
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: 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].vs,
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,
program_definitions[i].vs,
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, mask);
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: Implement simple shadow nodes
2017-12-01 09:27:31 +00:00
/* shadow */
gl renderer: Rename a macro
2017-12-01 12:56:56 +00:00
INIT_PROGRAM_UNIFORM_LOCATION (shadow, color);
gl renderer: Implement simple shadow nodes
2017-12-01 09:27:31 +00:00
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: 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);
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
}
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,
GdkWindow *window,
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);
Rework the GL renderer
2017-11-03 12:09:02 +00:00
self->scale_factor = gdk_window_get_scale_factor (window);
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
/* 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
{
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
self->gl_context = gdk_window_create_gl_context (window, error);
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
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_NOTE (OPENGL, g_print ("Creating buffers and programs\n"));
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
gl: Add glyph cache Based on the one used by the vulkan renderer
2017-11-18 13:30:57 +00:00
gsk_gl_glyph_cache_init (&self->glyph_cache, 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
return TRUE;
}
static void
gsk_gl_renderer_unrealize (GskRenderer *renderer)
{
GskGLRenderer *self = GSK_GL_RENDERER (renderer);
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
Rework the GL renderer
2017-11-03 12:09:02 +00:00
glDeleteProgram (self->blend_program.id);
glDeleteProgram (self->blit_program.id);
glDeleteProgram (self->color_program.id);
gl: Add glyph cache Based on the one used by the vulkan renderer
2017-11-18 13:30:57 +00:00
glDeleteProgram (self->coloring_program.id);
Rework the GL renderer
2017-11-03 12:09:02 +00:00
glDeleteProgram (self->color_matrix_program.id);
glDeleteProgram (self->linear_gradient_program.id);
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_gl_renderer_destroy_buffers (self);
gl: Add glyph cache Based on the one used by the vulkan renderer
2017-11-18 13:30:57 +00:00
gsk_gl_glyph_cache_free (&self->glyph_cache);
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
}
glrenderer: Always redraw the whole screen
2016-11-27 15:37:31 +00:00
static GdkDrawingContext *
gsk_gl_renderer_begin_draw_frame (GskRenderer *renderer,
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
const cairo_region_t *update_area)
glrenderer: Always redraw the whole screen
2016-11-27 15:37:31 +00:00
{
GskGLRenderer *self = GSK_GL_RENDERER (renderer);
gdkgl: Add gdk_gl_context_get_damage() This is a way to query the damaged area of the backbuffer. The GL renderer uses this to compute the extents of that damage region (computed via buffer age) and use them to minimize the area to redraw. This changes the semantics of GL rendering to "When calling gdk_window_begin_frame() with a GL context, the area by gdk_gl_context_get_damage() needs to be redrawn and every other pixel of the backbuffer is guaranteed to be correct. After gdk_window_end_frame() on a GL-drawn window, the whole backbuffer must be correct. We can always glXBufferSwap() now because of this.
2016-12-04 15:33:13 +00:00
cairo_region_t *damage;
glrenderer: Always redraw the whole screen
2016-11-27 15:37:31 +00:00
GdkDrawingContext *result;
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
GdkRectangle whole_window;
glrenderer: Always redraw the whole screen
2016-11-27 15:37:31 +00:00
GdkWindow *window;
window = gsk_renderer_get_window (renderer);
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
whole_window = (GdkRectangle) {
0, 0,
Rework the GL renderer
2017-11-03 12:09:02 +00:00
gdk_window_get_width (window) * self->scale_factor,
gdk_window_get_height (window) * self->scale_factor
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
};
damage = gdk_gl_context_get_damage (self->gl_context);
cairo_region_union (damage, update_area);
Rework the GL renderer
2017-11-03 12:09:02 +00:00
gdkgl: Add gdk_gl_context_get_damage() This is a way to query the damaged area of the backbuffer. The GL renderer uses this to compute the extents of that damage region (computed via buffer age) and use them to minimize the area to redraw. This changes the semantics of GL rendering to "When calling gdk_window_begin_frame() with a GL context, the area by gdk_gl_context_get_damage() needs to be redrawn and every other pixel of the backbuffer is guaranteed to be correct. After gdk_window_end_frame() on a GL-drawn window, the whole backbuffer must be correct. We can always glXBufferSwap() now because of this.
2016-12-04 15:33:13 +00:00
if (cairo_region_contains_rectangle (damage, &whole_window) == CAIRO_REGION_OVERLAP_IN)
{
self->render_mode = RENDER_FULL;
}
else
{
GdkRectangle extents;
glrenderer: Always redraw the whole screen
2016-11-27 15:37:31 +00:00
gdkgl: Add gdk_gl_context_get_damage() This is a way to query the damaged area of the backbuffer. The GL renderer uses this to compute the extents of that damage region (computed via buffer age) and use them to minimize the area to redraw. This changes the semantics of GL rendering to "When calling gdk_window_begin_frame() with a GL context, the area by gdk_gl_context_get_damage() needs to be redrawn and every other pixel of the backbuffer is guaranteed to be correct. After gdk_window_end_frame() on a GL-drawn window, the whole backbuffer must be correct. We can always glXBufferSwap() now because of this.
2016-12-04 15:33:13 +00:00
cairo_region_get_extents (damage, &extents);
cairo_region_union_rectangle (damage, &extents);
glrenderer: Always redraw the whole screen
2016-11-27 15:37:31 +00:00
gdkgl: Add gdk_gl_context_get_damage() This is a way to query the damaged area of the backbuffer. The GL renderer uses this to compute the extents of that damage region (computed via buffer age) and use them to minimize the area to redraw. This changes the semantics of GL rendering to "When calling gdk_window_begin_frame() with a GL context, the area by gdk_gl_context_get_damage() needs to be redrawn and every other pixel of the backbuffer is guaranteed to be correct. After gdk_window_end_frame() on a GL-drawn window, the whole backbuffer must be correct. We can always glXBufferSwap() now because of this.
2016-12-04 15:33:13 +00:00
if (gdk_rectangle_equal (&extents, &whole_window))
self->render_mode = RENDER_FULL;
else
self->render_mode = RENDER_SCISSOR;
}
glrenderer: Always redraw the whole screen
2016-11-27 15:37:31 +00:00
gdkgl: Add gdk_gl_context_get_damage() This is a way to query the damaged area of the backbuffer. The GL renderer uses this to compute the extents of that damage region (computed via buffer age) and use them to minimize the area to redraw. This changes the semantics of GL rendering to "When calling gdk_window_begin_frame() with a GL context, the area by gdk_gl_context_get_damage() needs to be redrawn and every other pixel of the backbuffer is guaranteed to be correct. After gdk_window_end_frame() on a GL-drawn window, the whole backbuffer must be correct. We can always glXBufferSwap() now because of this.
2016-12-04 15:33:13 +00:00
result = gdk_window_begin_draw_frame (window,
GDK_DRAW_CONTEXT (self->gl_context),
damage);
glrenderer: Always redraw the whole screen
2016-11-27 15:37:31 +00:00
gdkgl: Add gdk_gl_context_get_damage() This is a way to query the damaged area of the backbuffer. The GL renderer uses this to compute the extents of that damage region (computed via buffer age) and use them to minimize the area to redraw. This changes the semantics of GL rendering to "When calling gdk_window_begin_frame() with a GL context, the area by gdk_gl_context_get_damage() needs to be redrawn and every other pixel of the backbuffer is guaranteed to be correct. After gdk_window_end_frame() on a GL-drawn window, the whole backbuffer must be correct. We can always glXBufferSwap() now because of this.
2016-12-04 15:33:13 +00:00
cairo_region_destroy (damage);
glrenderer: Always redraw the whole screen
2016-11-27 15:37:31 +00:00
return result;
}
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: 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_resize_viewport (GskGLRenderer *self,
Rework the GL renderer
2017-11-03 12:09:02 +00:00
const graphene_rect_t *viewport)
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
int width = viewport->size.width;
int height = viewport->size.height;
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: Take into account the scaling factor We need to apply a scaling factor whenever we deal with user-supplied coordinates, like: - when creating textures - when setting up the viewport - when submitting the scene
2016-07-27 15:48:35 +00:00
GSK_NOTE (OPENGL, g_print ("glViewport(0, 0, %d, %d) [scale:%d]\n",
width,
height,
Rework the GL renderer
2017-11-03 12:09:02 +00:00
self->scale_factor));
gsk: Take into account the scaling factor We need to apply a scaling factor whenever we deal with user-supplied coordinates, like: - when creating textures - when setting up the viewport - when submitting the scene
2016-07-27 15:48:35 +00:00
Rework the GL renderer
2017-11-03 12:09:02 +00:00
graphene_rect_init (&self->viewport, 0, 0, width, height);
gsk: Take into account the scaling factor We need to apply a scaling factor whenever we deal with user-supplied coordinates, like: - when creating textures - when setting up the viewport - when submitting the scene
2016-07-27 15:48:35 +00:00
glViewport (0, 0, width, height);
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
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
GSK_NOTE (OPENGL, g_print ("Collected: %d textures\n",
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
{
gl renderer: Rework once more Last time, I swear.
2017-11-22 10:32:23 +00:00
GSK_NOTE (OPENGL, g_print ("Clearing viewport\n"));
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
{
gl renderer: Rework once more Last time, I swear.
2017-11-22 10:32:23 +00:00
switch (self->render_mode)
{
case RENDER_FULL:
glDisable (GL_SCISSOR_TEST);
break;
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 RENDER_SCISSOR:
gl renderer: Group render node types by render item creation
2017-11-20 13:30:46 +00:00
{
gl renderer: Rework once more Last time, I swear.
2017-11-22 10:32:23 +00:00
GdkDrawingContext *context = gsk_renderer_get_drawing_context (GSK_RENDERER (self));
GdkWindow *window = gsk_renderer_get_window (GSK_RENDERER (self));
cairo_region_t *clip = gdk_drawing_context_get_clip (context);
cairo_rectangle_int_t extents;
int window_height;
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
/* Fall back to RENDER_FULL */
if (clip == NULL)
gl renderer: Group render node types by render item creation
2017-11-20 13:30:46 +00:00
{
gl renderer: Rework once more Last time, I swear.
2017-11-22 10:32:23 +00:00
glDisable (GL_SCISSOR_TEST);
return;
gl renderer: Group render node types by render item creation
2017-11-20 13:30:46 +00:00
}
gl renderer: Rework once more Last time, I swear.
2017-11-22 10:32:23 +00:00
g_assert (cairo_region_num_rectangles (clip) == 1);
gl renderer: Group render node types by render item creation
2017-11-20 13:30:46 +00:00
gl renderer: Rework once more Last time, I swear.
2017-11-22 10:32:23 +00:00
window_height = gdk_window_get_height (window) * self->scale_factor;
gl renderer: Group render node types by render item creation
2017-11-20 13:30:46 +00:00
gl renderer: Rework once more Last time, I swear.
2017-11-22 10:32:23 +00:00
/*cairo_region_get_extents (clip, &extents);*/
cairo_region_get_rectangle (clip, 0, &extents);
gl renderer: Group render node types by render item creation
2017-11-20 13:30:46 +00:00
gl renderer: Rework once more Last time, I swear.
2017-11-22 10:32:23 +00:00
glEnable (GL_SCISSOR_TEST);
glScissor (extents.x * self->scale_factor,
window_height - (extents.height * self->scale_factor) - (extents.y * self->scale_factor),
extents.width * self->scale_factor,
extents.height * self->scale_factor);
gl renderer: Group render node types by render item creation
2017-11-20 13:30:46 +00:00
gl renderer: Rework once more Last time, I swear.
2017-11-22 10:32:23 +00:00
cairo_region_destroy (clip);
break;
gl renderer: Group render node types by render item creation
2017-11-20 13:30:46 +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
default:
g_assert_not_reached ();
break;
}
}
Initial implementation of GSK rendering pipeline GSK is conceptually split into two scene graphs: * a simple rendering tree of operations * a complex set of logical layers The latter is built on the former, and adds convenience and high level API for application developers. The lower layer, though, is what gets transformed into the rendering pipeline, as it's simple and thus can be transformed into appropriate rendering commands with minimal state changes. The lower layer is also suitable for reuse from more complex higher layers, like the CSS machinery in GTK, without necessarily port those layers to the GSK high level API. This lower layer is based on GskRenderNode instances, which represent the tree of rendering operations; and a GskRenderer instance, which takes the render nodes and submits them (after potentially reordering and transforming them to a more appropriate representation) to the underlying graphic system.
2016-03-17 13:48:19 +00:00
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: Move render ops into separate file
2017-11-22 20:02:50 +00:00
#if DEBUG_OPS
if (gsk_render_node_get_node_type (node) != GSK_CONTAINER_NODE)
g_message ("Adding ops for node %s with type %u", node->name,
gsk_render_node_get_node_type (node));
#endif
gsk: Allow sampling between parent and child nodes
2016-06-30 16:06:31 +00:00
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
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: 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_texture_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: Add GskTexture
2016-11-07 16:59:38 +00:00
gl renderer: Implement cairo nodes again
2017-11-23 09:02:58 +00:00
case GSK_CAIRO_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_cairo_node (self, node, builder, vertex_data);
gl renderer: Implement cairo nodes again
2017-11-23 09:02:58 +00:00
break;
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: 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_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;
case GSK_REPEATING_LINEAR_GRADIENT_NODE:
Rework the GL renderer
2017-11-03 12:09:02 +00:00
case GSK_BLEND_NODE:
case GSK_REPEAT_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: Split out a utility function
2017-12-01 08:58:58 +00:00
render_fallback_node (self, node, builder, vertex_data);
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: Factor out a helper function for offscreen drawing
2017-11-24 09:18:51 +00:00
add_offscreen_ops (GskGLRenderer *self,
RenderOpBuilder *builder,
float min_x,
float max_x,
float min_y,
float max_y,
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
GskRenderNode *child_node,
int *texture_id,
gl renderer: Force cross-fade nodes offscreen
2017-12-19 11:45:32 +00:00
gboolean *is_offscreen,
gboolean force_offscreen)
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;
graphene_matrix_t identity;
graphene_matrix_t prev_projection;
graphene_matrix_t prev_modelview;
graphene_rect_t prev_viewport;
graphene_matrix_t item_proj;
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: Force cross-fade nodes offscreen
2017-12-19 11:45:32 +00:00
if (gsk_render_node_get_node_type (child_node) == GSK_TEXTURE_NODE && !force_offscreen)
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);
int gl_min_filter = GL_NEAREST, gl_mag_filter = GL_NEAREST;
get_gl_scaling_filters (child_node, &gl_min_filter, &gl_mag_filter);
*texture_id = gsk_gl_driver_get_texture_for_texture (self->gl_driver,
texture,
gl_min_filter,
gl_mag_filter);
*is_offscreen = FALSE;
return;
}
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
*texture_id = gsk_gl_driver_create_texture (self->gl_driver, max_x - min_x, max_y - min_y);
gsk_gl_driver_bind_source_texture (self->gl_driver, *texture_id);
gsk_gl_driver_init_texture_empty (self->gl_driver, *texture_id);
render_target = gsk_gl_driver_create_render_target (self->gl_driver, *texture_id, TRUE, TRUE);
gl renderer: Factor out a helper function for offscreen drawing
2017-11-24 09:18:51 +00:00
graphene_matrix_init_ortho (&item_proj,
min_x, max_x,
min_y, max_y,
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);
/* 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);
prev_modelview = ops_set_modelview (builder, &identity);
prev_viewport = ops_set_viewport (builder, &GRAPHENE_RECT_INIT (min_x, min_y, max_x - min_x, max_y - min_y));
gsk_gl_renderer_add_render_ops (self, child_node, builder);
ops_set_viewport (builder, &prev_viewport);
ops_set_modelview (builder, &prev_modelview);
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;
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
gl renderer: Ignore render ops before we have a valid program
2017-12-08 19:43:47 +00:00
if (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: 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: 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;
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,
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);
gl renderer: Rework once more Last time, I swear.
2017-11-22 10:32:23 +00:00
RenderOpBuilder render_op_builder;
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;
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;
gint64 gpu_time, 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
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_NOTE (OPENGL, g_print ("No valid GL context associated to the renderer"));
return;
}
self->viewport = *viewport;
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
gsk_gl_driver_begin_frame (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_gl_glyph_cache_begin_frame (&self->glyph_cache);
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: Rework once more Last time, I swear.
2017-11-22 10:32:23 +00:00
memset (&render_op_builder, 0, sizeof (render_op_builder));
render_op_builder.renderer = self;
render_op_builder.current_projection = projection;
render_op_builder.current_modelview = modelview;
render_op_builder.current_viewport = *viewport;
render_op_builder.current_opacity = 1.0f;
gl renderer: Move render ops into separate file
2017-11-22 20:02:50 +00:00
render_op_builder.render_ops = self->render_ops;
gl renderer: Rework once more Last time, I swear.
2017-11-22 10:32:23 +00:00
gsk_rounded_rect_init_from_rect (&render_op_builder.current_clip, &self->viewport, 0.0f);
gl renderer: Insert render target op in render_texture path
2017-12-27 22:15:07 +00:00
if (self->texture_id != 0)
ops_set_render_target (&render_op_builder, self->texture_id);
gl renderer: Rework once more Last time, I swear.
2017-11-22 10:32:23 +00:00
gsk_gl_renderer_add_render_ops (self, root, &render_op_builder);
/*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
Rework the GL renderer
2017-11-03 12:09:02 +00:00
gsk_gl_renderer_resize_viewport (self, viewport);
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
gl renderer: Rework once more Last time, I swear.
2017-11-22 10:32:23 +00:00
gsk_gl_renderer_render_ops (self, render_op_builder.buffer_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: 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_gl_driver_end_frame (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
#ifdef G_ENABLE_DEBUG
gsk_profiler_counter_inc (profiler, self->profile_counters.frames);
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);
#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 stride;
gl renderer: Properly flip texture in render_texture path Just do this on the CPU instead.
2017-12-28 10:03:33 +00:00
guchar *data, *data2;
Rework the GL renderer
2017-11-03 12:09:02 +00:00
int width, height;
gl renderer: Properly flip texture in render_texture path Just do this on the CPU instead.
2017-12-28 10:03:33 +00:00
int x, y;
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);
self->render_mode = RENDER_FULL;
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
gdk_gl_context_make_current (self->gl_context);
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);
Rework the GL renderer
2017-11-03 12:09:02 +00:00
gsk_gl_renderer_create_buffers (self, width, height, 1);
gsk_gl_renderer_clear (self);
gsk: Implement gsk_renderer_render_texture() on GL
2016-12-22 19:01:52 +00:00
gsk_gl_driver_end_frame (self->gl_driver);
gl renderer: Properly flip texture in render_texture path Just do this on the CPU instead.
2017-12-28 10:03:33 +00:00
g_assert (self->texture_id != 0);
Rework the GL renderer
2017-11-03 12:09:02 +00:00
/* Render the actual scene */
gsk: Implement gsk_renderer_render_texture() on GL
2016-12-22 19:01:52 +00:00
gsk_gl_renderer_do_render (renderer, root, viewport, 1);
Rework the GL renderer
2017-11-03 12:09:02 +00:00
/* Prepare memory for the glReadPixels call */
stride = cairo_format_stride_for_width (CAIRO_FORMAT_ARGB32, width);
data = g_malloc (height * stride);
/* Bind our framebuffer again and read from it */
gsk_gl_driver_begin_frame (self->gl_driver);
gsk_gl_driver_bind_render_target (self->gl_driver, self->texture_id);
glReadPixels (0, 0, width, height, GL_BGRA, GL_UNSIGNED_INT_8_8_8_8_REV, data);
gsk_gl_driver_end_frame (self->gl_driver);
gl renderer: Properly flip texture in render_texture path Just do this on the CPU instead.
2017-12-28 10:03:33 +00:00
data2 = g_malloc (height * stride);
for (y = 0; y < height; y ++)
for (x = 0; x < stride; x ++)
data2[(height - 1 - y) * stride + x] = data[y * stride + x];
g_free (data);
Rework the GL renderer
2017-11-03 12:09:02 +00:00
/* Create texture from the downloaded data */
gl renderer: Properly flip texture in render_texture path Just do this on the CPU instead.
2017-12-28 10:03:33 +00:00
texture = gdk_texture_new_for_data (g_steal_pointer (&data2), width, height, stride);
gsk: Implement gsk_renderer_render_texture() on GL
2016-12-22 19:01:52 +00:00
return texture;
}
static void
gsk_gl_renderer_render (GskRenderer *renderer,
GskRenderNode *root)
{
GskGLRenderer *self = GSK_GL_RENDERER (renderer);
Rework the GL renderer
2017-11-03 12:09:02 +00:00
GdkWindow *window = gsk_renderer_get_window (renderer);
gsk: Implement gsk_renderer_render_texture() on GL
2016-12-22 19:01:52 +00:00
graphene_rect_t viewport;
if (self->gl_context == NULL)
return;
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;
viewport.size.width = gdk_window_get_width (window) * self->scale_factor;
viewport.size.height = gdk_window_get_height (window) * self->scale_factor;
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
gsk_gl_renderer_do_render (renderer, root, &viewport, self->scale_factor);
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: 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);
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: 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
gsk_gl_renderer_destroy_buffers (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
}
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;
glrenderer: Always redraw the whole screen
2016-11-27 15:37:31 +00:00
renderer_class->begin_draw_frame = gsk_gl_renderer_begin_draw_frame;
Initial implementation of GSK rendering pipeline GSK is conceptually split into two scene graphs: * a simple rendering tree of operations * a complex set of logical layers The latter is built on the former, and adds convenience and high level API for application developers. The lower layer, though, is what gets transformed into the rendering pipeline, as it's simple and thus can be transformed into appropriate rendering commands with minimal state changes. The lower layer is also suitable for reuse from more complex higher layers, like the CSS machinery in GTK, without necessarily port those layers to the GSK high level API. This lower layer is based on GskRenderNode instances, which represent the tree of rendering operations; and a GskRenderer instance, which takes the render nodes and submits them (after potentially reordering and transforming them to a more appropriate representation) to the underlying graphic system.
2016-03-17 13:48:19 +00:00
renderer_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: Add glyph cache Based on the one used by the vulkan renderer
2017-11-18 13:30:57 +00:00
Rework the GL renderer
2017-11-03 12:09:02 +00:00
self->scale_factor = 1;
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
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
}
Reference in New Issue Copy Permalink