forked from AuroraMiddleware/gtk
712 lines
21 KiB
C
712 lines
21 KiB
C
#include "config.h"
|
|
|
|
#include "gskbroadwayrendererprivate.h"
|
|
#include "broadway/gdkprivate-broadway.h"
|
|
|
|
#include "gskdebugprivate.h"
|
|
#include "gskrendererprivate.h"
|
|
#include "gskrendernodeprivate.h"
|
|
#include "gdk/gdktextureprivate.h"
|
|
|
|
|
|
struct _GskBroadwayRenderer
|
|
{
|
|
GskRenderer parent_instance;
|
|
|
|
};
|
|
|
|
struct _GskBroadwayRendererClass
|
|
{
|
|
GskRendererClass parent_class;
|
|
};
|
|
|
|
G_DEFINE_TYPE (GskBroadwayRenderer, gsk_broadway_renderer, GSK_TYPE_RENDERER)
|
|
|
|
static gboolean
|
|
gsk_broadway_renderer_realize (GskRenderer *self,
|
|
GdkSurface *surface,
|
|
GError **error)
|
|
{
|
|
return TRUE;
|
|
}
|
|
|
|
static void
|
|
gsk_broadway_renderer_unrealize (GskRenderer *self)
|
|
{
|
|
|
|
}
|
|
|
|
static GdkTexture *
|
|
gsk_broadway_renderer_render_texture (GskRenderer *self,
|
|
GskRenderNode *root,
|
|
const graphene_rect_t *viewport)
|
|
{
|
|
GdkTexture *texture;
|
|
cairo_surface_t *surface;
|
|
cairo_t *cr;
|
|
|
|
surface = cairo_image_surface_create (CAIRO_FORMAT_ARGB32, ceil (viewport->size.width), ceil (viewport->size.height));
|
|
cr = cairo_create (surface);
|
|
|
|
cairo_translate (cr, - viewport->origin.x, - viewport->origin.y);
|
|
|
|
gsk_render_node_draw (root, cr);
|
|
|
|
cairo_destroy (cr);
|
|
|
|
texture = gdk_texture_new_for_surface (surface);
|
|
cairo_surface_destroy (surface);
|
|
|
|
return texture;
|
|
}
|
|
|
|
static void
|
|
add_uint32 (GArray *nodes, guint32 v)
|
|
{
|
|
g_array_append_val (nodes, v);
|
|
}
|
|
|
|
static guint32
|
|
rgba_to_uint32 (const GdkRGBA *rgba)
|
|
{
|
|
return
|
|
((guint32)(0.5 + CLAMP (rgba->alpha, 0., 1.) * 255.) << 24) |
|
|
((guint32)(0.5 + CLAMP (rgba->red, 0., 1.) * 255.) << 16) |
|
|
((guint32)(0.5 + CLAMP (rgba->green, 0., 1.) * 255.) << 8) |
|
|
((guint32)(0.5 + CLAMP (rgba->blue, 0., 1.) * 255.) << 0);
|
|
}
|
|
|
|
|
|
static void
|
|
add_rgba (GArray *nodes, const GdkRGBA *rgba)
|
|
{
|
|
guint32 c = rgba_to_uint32 (rgba);
|
|
g_array_append_val (nodes, c);
|
|
}
|
|
|
|
static void
|
|
add_float (GArray *nodes, float f)
|
|
{
|
|
gint32 i = (gint32) (f * 256.0f);
|
|
guint u = (guint32) i;
|
|
g_array_append_val (nodes, u);
|
|
}
|
|
|
|
static void
|
|
add_point (GArray *nodes, const graphene_point_t *point, float offset_x, float offset_y)
|
|
{
|
|
add_float (nodes, point->x - offset_x);
|
|
add_float (nodes, point->y - offset_y);
|
|
}
|
|
|
|
static void
|
|
add_size (GArray *nodes, const graphene_size_t *size)
|
|
{
|
|
add_float (nodes, size->width);
|
|
add_float (nodes, size->height);
|
|
}
|
|
|
|
static void
|
|
add_rect (GArray *nodes, const graphene_rect_t *rect, float offset_x, float offset_y)
|
|
{
|
|
add_point (nodes, &rect->origin, offset_x, offset_y);
|
|
add_size (nodes, &rect->size);
|
|
}
|
|
|
|
static void
|
|
add_rounded_rect (GArray *nodes, const GskRoundedRect *rrect, float offset_x, float offset_y)
|
|
{
|
|
int i;
|
|
add_rect (nodes, &rrect->bounds, offset_x, offset_y);
|
|
for (i = 0; i < 4; i++)
|
|
add_size (nodes, &rrect->corner[i]);
|
|
}
|
|
|
|
static void
|
|
add_color_stop (GArray *nodes, const GskColorStop *stop)
|
|
{
|
|
add_float (nodes, stop->offset);
|
|
add_rgba (nodes, &stop->color);
|
|
}
|
|
|
|
static gboolean
|
|
float_is_int32 (float f)
|
|
{
|
|
gint32 i = (gint32)f;
|
|
float f2 = (float)i;
|
|
return f2 == f;
|
|
}
|
|
|
|
static GHashTable *gsk_broadway_node_cache;
|
|
|
|
typedef struct {
|
|
GdkTexture *texture;
|
|
GskRenderNode *node;
|
|
float off_x;
|
|
float off_y;
|
|
} NodeCacheElement;
|
|
|
|
static void
|
|
node_cache_element_free (NodeCacheElement *element)
|
|
{
|
|
gsk_render_node_unref (element->node);
|
|
g_free (element);
|
|
}
|
|
|
|
static guint
|
|
glyph_info_hash (const PangoGlyphInfo *info)
|
|
{
|
|
return info->glyph ^
|
|
info->geometry.width << 6 ^
|
|
info->geometry.x_offset << 12 ^
|
|
info->geometry.y_offset << 18 ^
|
|
info->attr.is_cluster_start << 30;
|
|
}
|
|
|
|
static gboolean
|
|
glyph_info_equal (const PangoGlyphInfo *a,
|
|
const PangoGlyphInfo *b)
|
|
{
|
|
return
|
|
a->glyph == b->glyph &&
|
|
a->geometry.width == b->geometry.width &&
|
|
a->geometry.x_offset == b->geometry.x_offset &&
|
|
a->geometry.y_offset == b->geometry.y_offset &&
|
|
a->attr.is_cluster_start == b->attr.is_cluster_start;
|
|
}
|
|
|
|
static guint
|
|
hash_matrix (const graphene_matrix_t *matrix)
|
|
{
|
|
float m[16];
|
|
guint h = 0;
|
|
int i;
|
|
|
|
graphene_matrix_to_float (matrix, m);
|
|
for (i = 0; i < 16; i++)
|
|
h ^= (guint) m[i];
|
|
|
|
return h;
|
|
}
|
|
|
|
static gboolean
|
|
matrix_equal (const graphene_matrix_t *a,
|
|
const graphene_matrix_t *b)
|
|
{
|
|
float ma[16];
|
|
float mb[16];
|
|
int i;
|
|
|
|
graphene_matrix_to_float (a, ma);
|
|
graphene_matrix_to_float (b, mb);
|
|
for (i = 0; i < 16; i++)
|
|
{
|
|
if (ma[i] != mb[i])
|
|
return FALSE;
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
static guint
|
|
hash_vec4 (const graphene_vec4_t *vec4)
|
|
{
|
|
float v[4];
|
|
guint h = 0;
|
|
int i;
|
|
|
|
graphene_vec4_to_float (vec4, v);
|
|
for (i = 0; i < 4; i++)
|
|
h ^= (guint) v[i];
|
|
|
|
return h;
|
|
}
|
|
|
|
static gboolean
|
|
vec4_equal (const graphene_vec4_t *a,
|
|
const graphene_vec4_t *b)
|
|
{
|
|
float va[4];
|
|
float vb[4];
|
|
int i;
|
|
|
|
graphene_vec4_to_float (a, va);
|
|
graphene_vec4_to_float (b, vb);
|
|
for (i = 0; i < 4; i++)
|
|
{
|
|
if (va[i] != vb[i])
|
|
return FALSE;
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
static guint
|
|
node_cache_hash (GskRenderNode *node)
|
|
{
|
|
GskRenderNodeType type;
|
|
guint h;
|
|
|
|
type = gsk_render_node_get_node_type (node);
|
|
h = type << 28;
|
|
if (type == GSK_TEXT_NODE &&
|
|
float_is_int32 (gsk_text_node_get_x (node)) &&
|
|
float_is_int32 (gsk_text_node_get_y (node)))
|
|
{
|
|
guint i;
|
|
const PangoFont *font = gsk_text_node_peek_font (node);
|
|
guint n_glyphs = gsk_text_node_get_num_glyphs (node);
|
|
const PangoGlyphInfo *infos = gsk_text_node_peek_glyphs (node);
|
|
const GdkRGBA *color = gsk_text_node_peek_color (node);
|
|
|
|
h ^= g_direct_hash (font) ^ n_glyphs << 16 ^ gdk_rgba_hash (color);
|
|
for (i = 0; i < n_glyphs; i++)
|
|
h ^= glyph_info_hash (&infos[i]);
|
|
|
|
return h;
|
|
}
|
|
|
|
if (type == GSK_COLOR_MATRIX_NODE &&
|
|
gsk_render_node_get_node_type (gsk_color_matrix_node_get_child (node)) == GSK_TEXTURE_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);
|
|
GskRenderNode *child = gsk_color_matrix_node_get_child (node);
|
|
GdkTexture *texture = gsk_texture_node_get_texture (child);
|
|
|
|
h ^= g_direct_hash (texture) ^ hash_matrix (matrix) ^ hash_vec4 (offset);
|
|
|
|
return h;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
static gboolean
|
|
node_cache_equal (GskRenderNode *a,
|
|
GskRenderNode *b)
|
|
{
|
|
GskRenderNodeType type;
|
|
|
|
type = gsk_render_node_get_node_type (a);
|
|
if (type != gsk_render_node_get_node_type (b))
|
|
return FALSE;
|
|
|
|
if (type == GSK_TEXT_NODE &&
|
|
float_is_int32 (gsk_text_node_get_x (a)) &&
|
|
float_is_int32 (gsk_text_node_get_y (a)) &&
|
|
float_is_int32 (gsk_text_node_get_x (b)) &&
|
|
float_is_int32 (gsk_text_node_get_y (b)))
|
|
{
|
|
const PangoFont *a_font = gsk_text_node_peek_font (a);
|
|
guint a_n_glyphs = gsk_text_node_get_num_glyphs (a);
|
|
const PangoGlyphInfo *a_infos = gsk_text_node_peek_glyphs (a);
|
|
const GdkRGBA *a_color = gsk_text_node_peek_color (a);
|
|
const PangoFont *b_font = gsk_text_node_peek_font (b);
|
|
guint b_n_glyphs = gsk_text_node_get_num_glyphs (b);
|
|
const PangoGlyphInfo *b_infos = gsk_text_node_peek_glyphs (b);
|
|
const GdkRGBA *b_color = gsk_text_node_peek_color (a);
|
|
guint i;
|
|
|
|
if (a_font != b_font)
|
|
return FALSE;
|
|
|
|
if (a_n_glyphs != b_n_glyphs)
|
|
return FALSE;
|
|
|
|
for (i = 0; i < a_n_glyphs; i++)
|
|
{
|
|
if (!glyph_info_equal (&a_infos[i], &b_infos[i]))
|
|
return FALSE;
|
|
}
|
|
|
|
if (!gdk_rgba_equal (a_color, b_color))
|
|
return FALSE;
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
if (type == GSK_COLOR_MATRIX_NODE &&
|
|
gsk_render_node_get_node_type (gsk_color_matrix_node_get_child (a)) == GSK_TEXTURE_NODE &&
|
|
gsk_render_node_get_node_type (gsk_color_matrix_node_get_child (b)) == GSK_TEXTURE_NODE)
|
|
{
|
|
const graphene_matrix_t *a_matrix = gsk_color_matrix_node_peek_color_matrix (a);
|
|
const graphene_vec4_t *a_offset = gsk_color_matrix_node_peek_color_offset (a);
|
|
GskRenderNode *a_child = gsk_color_matrix_node_get_child (a);
|
|
GdkTexture *a_texture = gsk_texture_node_get_texture (a_child);
|
|
const graphene_matrix_t *b_matrix = gsk_color_matrix_node_peek_color_matrix (b);
|
|
const graphene_vec4_t *b_offset = gsk_color_matrix_node_peek_color_offset (b);
|
|
GskRenderNode *b_child = gsk_color_matrix_node_get_child (b);
|
|
GdkTexture *b_texture = gsk_texture_node_get_texture (b_child);
|
|
|
|
if (a_texture != b_texture)
|
|
return FALSE;
|
|
|
|
if (!matrix_equal (a_matrix, b_matrix))
|
|
return FALSE;
|
|
|
|
if (!vec4_equal (a_offset, b_offset))
|
|
return FALSE;
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
static GdkTexture *
|
|
node_cache_lookup (GskRenderNode *node,
|
|
float *off_x, float *off_y)
|
|
{
|
|
NodeCacheElement *hit;
|
|
|
|
if (gsk_broadway_node_cache == NULL)
|
|
gsk_broadway_node_cache = g_hash_table_new_full ((GHashFunc)node_cache_hash,
|
|
(GEqualFunc)node_cache_equal,
|
|
NULL,
|
|
(GDestroyNotify)node_cache_element_free);
|
|
|
|
hit = g_hash_table_lookup (gsk_broadway_node_cache, node);
|
|
if (hit)
|
|
{
|
|
*off_x = hit->off_x;
|
|
*off_y = hit->off_y;
|
|
return g_object_ref (hit->texture);
|
|
}
|
|
|
|
return NULL;
|
|
}
|
|
|
|
static void
|
|
cached_texture_gone (gpointer data,
|
|
GObject *where_the_object_was)
|
|
{
|
|
NodeCacheElement *element = data;
|
|
g_hash_table_remove (gsk_broadway_node_cache, element->node);
|
|
}
|
|
|
|
static void
|
|
node_cache_store (GskRenderNode *node,
|
|
GdkTexture *texture,
|
|
float off_x,
|
|
float off_y)
|
|
{
|
|
GskRenderNodeType type;
|
|
|
|
type = gsk_render_node_get_node_type (node);
|
|
if ((type == GSK_TEXT_NODE &&
|
|
float_is_int32 (gsk_text_node_get_x (node)) &&
|
|
float_is_int32 (gsk_text_node_get_y (node))) ||
|
|
(type == GSK_COLOR_MATRIX_NODE &&
|
|
gsk_render_node_get_node_type (gsk_color_matrix_node_get_child (node)) == GSK_TEXTURE_NODE))
|
|
{
|
|
NodeCacheElement *element = g_new0 (NodeCacheElement, 1);
|
|
element->texture = texture;
|
|
element->node = gsk_render_node_ref (node);
|
|
element->off_x = off_x;
|
|
element->off_y = off_y;
|
|
g_object_weak_ref (G_OBJECT (texture), cached_texture_gone, element);
|
|
g_hash_table_insert (gsk_broadway_node_cache, element->node, element);
|
|
|
|
return;
|
|
}
|
|
}
|
|
|
|
static GdkTexture *
|
|
node_texture_fallback (GskRenderNode *node,
|
|
float *off_x,
|
|
float *off_y)
|
|
{
|
|
cairo_surface_t *surface;
|
|
cairo_t *cr;
|
|
int x = floorf (node->bounds.origin.x);
|
|
int y = floorf (node->bounds.origin.y);
|
|
int width = ceil (node->bounds.origin.x + node->bounds.size.width) - x;
|
|
int height = ceil (node->bounds.origin.y + node->bounds.size.height) - y;
|
|
GdkTexture *texture;
|
|
|
|
surface = cairo_image_surface_create (CAIRO_FORMAT_ARGB32, width, height);
|
|
cr = cairo_create (surface);
|
|
cairo_translate (cr, -x, -y);
|
|
gsk_render_node_draw (node, cr);
|
|
cairo_destroy (cr);
|
|
|
|
texture = gdk_texture_new_for_surface (surface);
|
|
*off_x = x - node->bounds.origin.x;
|
|
*off_y = y - node->bounds.origin.y;
|
|
|
|
return texture;
|
|
}
|
|
|
|
/* Note: This tracks the offset so that we can convert
|
|
the absolute coordinates of the GskRenderNodes to
|
|
parent-relative which is what the dom uses, and
|
|
which is good for re-using subtrees. */
|
|
static void
|
|
gsk_broadway_renderer_add_node (GskRenderer *self,
|
|
GArray *nodes,
|
|
GPtrArray *node_textures,
|
|
GskRenderNode *node,
|
|
float offset_x,
|
|
float offset_y)
|
|
{
|
|
GdkDisplay *display = gsk_renderer_get_display (self);
|
|
|
|
switch (gsk_render_node_get_node_type (node))
|
|
{
|
|
case GSK_NOT_A_RENDER_NODE:
|
|
g_assert_not_reached ();
|
|
return;
|
|
|
|
/* Leaf nodes */
|
|
|
|
case GSK_TEXTURE_NODE:
|
|
{
|
|
GdkTexture *texture = gsk_texture_node_get_texture (node);
|
|
guint32 texture_id;
|
|
|
|
g_ptr_array_add (node_textures, g_object_ref (texture)); /* Transfers ownership to node_textures */
|
|
texture_id = gdk_broadway_display_ensure_texture (display, texture);
|
|
|
|
add_uint32 (nodes, BROADWAY_NODE_TEXTURE);
|
|
add_rect (nodes, &node->bounds, offset_x, offset_y);
|
|
add_uint32 (nodes, texture_id);
|
|
}
|
|
return;
|
|
|
|
case GSK_CAIRO_NODE:
|
|
{
|
|
const cairo_surface_t *surface = gsk_cairo_node_peek_surface (node);
|
|
GdkTexture *texture;
|
|
guint32 texture_id;
|
|
|
|
texture = gdk_texture_new_for_surface ((cairo_surface_t *)surface);
|
|
g_ptr_array_add (node_textures, g_object_ref (texture)); /* Transfers ownership to node_textures */
|
|
texture_id = gdk_broadway_display_ensure_texture (display, texture);
|
|
|
|
add_uint32 (nodes, BROADWAY_NODE_TEXTURE);
|
|
add_rect (nodes, &node->bounds, offset_x, offset_y);
|
|
add_uint32 (nodes, texture_id);
|
|
}
|
|
return;
|
|
|
|
case GSK_COLOR_NODE:
|
|
{
|
|
add_uint32 (nodes, BROADWAY_NODE_COLOR);
|
|
add_rect (nodes, &node->bounds, offset_x, offset_y);
|
|
add_rgba (nodes, gsk_color_node_peek_color (node));
|
|
}
|
|
return;
|
|
|
|
case GSK_BORDER_NODE:
|
|
{
|
|
int i;
|
|
add_uint32 (nodes, BROADWAY_NODE_BORDER);
|
|
add_rounded_rect (nodes, gsk_border_node_peek_outline (node), offset_x, offset_y);
|
|
for (i = 0; i < 4; i++)
|
|
add_float (nodes, gsk_border_node_peek_widths (node)[i]);
|
|
for (i = 0; i < 4; i++)
|
|
add_rgba (nodes, &gsk_border_node_peek_colors (node)[i]);
|
|
}
|
|
return;
|
|
|
|
case GSK_OUTSET_SHADOW_NODE:
|
|
{
|
|
add_uint32 (nodes, BROADWAY_NODE_OUTSET_SHADOW);
|
|
add_rounded_rect (nodes, gsk_outset_shadow_node_peek_outline (node), offset_x, offset_y);
|
|
add_rgba (nodes, gsk_outset_shadow_node_peek_color (node));
|
|
add_float (nodes, gsk_outset_shadow_node_get_dx (node));
|
|
add_float (nodes, gsk_outset_shadow_node_get_dy (node));
|
|
add_float (nodes, gsk_outset_shadow_node_get_spread (node));
|
|
add_float (nodes, gsk_outset_shadow_node_get_blur_radius (node));
|
|
}
|
|
return;
|
|
|
|
case GSK_INSET_SHADOW_NODE:
|
|
{
|
|
add_uint32 (nodes, BROADWAY_NODE_INSET_SHADOW);
|
|
add_rounded_rect (nodes, gsk_inset_shadow_node_peek_outline (node), offset_x, offset_y);
|
|
add_rgba (nodes, gsk_inset_shadow_node_peek_color (node));
|
|
add_float (nodes, gsk_inset_shadow_node_get_dx (node));
|
|
add_float (nodes, gsk_inset_shadow_node_get_dy (node));
|
|
add_float (nodes, gsk_inset_shadow_node_get_spread (node));
|
|
add_float (nodes, gsk_inset_shadow_node_get_blur_radius (node));
|
|
}
|
|
return;
|
|
|
|
case GSK_LINEAR_GRADIENT_NODE:
|
|
{
|
|
guint i, n;
|
|
|
|
add_uint32 (nodes, BROADWAY_NODE_LINEAR_GRADIENT);
|
|
add_rect (nodes, &node->bounds, offset_x, offset_y);
|
|
add_point (nodes, gsk_linear_gradient_node_peek_start (node), offset_x, offset_y);
|
|
add_point (nodes, gsk_linear_gradient_node_peek_end (node), offset_x, offset_y);
|
|
n = gsk_linear_gradient_node_get_n_color_stops (node);
|
|
add_uint32 (nodes, n);
|
|
for (i = 0; i < n; i++)
|
|
add_color_stop (nodes, &gsk_linear_gradient_node_peek_color_stops (node)[i]);
|
|
}
|
|
return;
|
|
|
|
/* Bin nodes */
|
|
|
|
case GSK_SHADOW_NODE:
|
|
{
|
|
gsize i, n_shadows = gsk_shadow_node_get_n_shadows (node);
|
|
add_uint32 (nodes, BROADWAY_NODE_SHADOW);
|
|
add_uint32 (nodes, n_shadows);
|
|
for (i = 0; i < n_shadows; i++)
|
|
{
|
|
const GskShadow *shadow = gsk_shadow_node_peek_shadow (node, i);
|
|
add_rgba (nodes, &shadow->color);
|
|
add_float (nodes, shadow->dx);
|
|
add_float (nodes, shadow->dy);
|
|
add_float (nodes, shadow->radius);
|
|
}
|
|
gsk_broadway_renderer_add_node (self, nodes, node_textures,
|
|
gsk_shadow_node_get_child (node),
|
|
offset_x, offset_y);
|
|
}
|
|
return;
|
|
|
|
case GSK_OPACITY_NODE:
|
|
{
|
|
add_uint32 (nodes, BROADWAY_NODE_OPACITY);
|
|
add_float (nodes, gsk_opacity_node_get_opacity (node));
|
|
gsk_broadway_renderer_add_node (self, nodes, node_textures,
|
|
gsk_opacity_node_get_child (node),
|
|
offset_x, offset_y);
|
|
}
|
|
return;
|
|
|
|
case GSK_ROUNDED_CLIP_NODE:
|
|
{
|
|
const GskRoundedRect *rclip = gsk_rounded_clip_node_peek_clip (node);
|
|
add_uint32 (nodes, BROADWAY_NODE_ROUNDED_CLIP);
|
|
add_rounded_rect (nodes, rclip, offset_x, offset_y);
|
|
gsk_broadway_renderer_add_node (self, nodes, node_textures,
|
|
gsk_rounded_clip_node_get_child (node),
|
|
rclip->bounds.origin.x,
|
|
rclip->bounds.origin.y);
|
|
}
|
|
return;
|
|
|
|
case GSK_CLIP_NODE:
|
|
{
|
|
const graphene_rect_t *clip = gsk_clip_node_peek_clip (node);
|
|
add_uint32 (nodes, BROADWAY_NODE_CLIP);
|
|
add_rect (nodes, clip, offset_x, offset_y);
|
|
gsk_broadway_renderer_add_node (self, nodes, node_textures,
|
|
gsk_clip_node_get_child (node),
|
|
clip->origin.x,
|
|
clip->origin.y);
|
|
}
|
|
return;
|
|
|
|
/* Generic nodes */
|
|
|
|
case GSK_CONTAINER_NODE:
|
|
{
|
|
guint i;
|
|
|
|
add_uint32 (nodes, BROADWAY_NODE_CONTAINER);
|
|
add_uint32 (nodes, gsk_container_node_get_n_children (node));
|
|
|
|
for (i = 0; i < gsk_container_node_get_n_children (node); i++)
|
|
gsk_broadway_renderer_add_node (self, nodes, node_textures,
|
|
gsk_container_node_get_child (node, i), offset_x, offset_y);
|
|
}
|
|
return;
|
|
|
|
case GSK_DEBUG_NODE:
|
|
gsk_broadway_renderer_add_node (self, nodes, node_textures,
|
|
gsk_debug_node_get_child (node), offset_x, offset_y);
|
|
return;
|
|
|
|
case GSK_COLOR_MATRIX_NODE:
|
|
case GSK_TEXT_NODE:
|
|
case GSK_REPEATING_LINEAR_GRADIENT_NODE:
|
|
case GSK_OFFSET_NODE:
|
|
case GSK_TRANSFORM_NODE:
|
|
case GSK_REPEAT_NODE:
|
|
case GSK_BLEND_NODE:
|
|
case GSK_CROSS_FADE_NODE:
|
|
case GSK_BLUR_NODE:
|
|
default:
|
|
break; /* Fallback */
|
|
}
|
|
|
|
{
|
|
GdkTexture *texture;
|
|
guint32 texture_id;
|
|
float t_off_x = 0, t_off_y = 0;
|
|
|
|
texture = node_cache_lookup (node, &t_off_x, &t_off_y);
|
|
|
|
if (!texture)
|
|
{
|
|
texture = node_texture_fallback (node, &t_off_x, &t_off_y);
|
|
#if 0
|
|
g_print ("Fallback %p for %s\n", texture, node->node_class->type_name);
|
|
#endif
|
|
|
|
node_cache_store (node, texture, t_off_x, t_off_y);
|
|
}
|
|
|
|
g_ptr_array_add (node_textures, texture); /* Transfers ownership to node_textures */
|
|
texture_id = gdk_broadway_display_ensure_texture (display, texture);
|
|
add_uint32 (nodes, BROADWAY_NODE_TEXTURE);
|
|
add_float (nodes, node->bounds.origin.x + t_off_x - offset_x);
|
|
add_float (nodes, node->bounds.origin.y + t_off_y - offset_y);
|
|
add_float (nodes, gdk_texture_get_width (texture));
|
|
add_float (nodes, gdk_texture_get_height (texture));
|
|
add_uint32 (nodes, texture_id);
|
|
}
|
|
}
|
|
|
|
static void
|
|
gsk_broadway_renderer_render (GskRenderer *self,
|
|
GskRenderNode *root,
|
|
const cairo_region_t *update_area)
|
|
{
|
|
GArray *nodes;
|
|
GPtrArray *node_textures;
|
|
cairo_region_t *whole;
|
|
GdkSurface *surface;
|
|
|
|
surface = gsk_renderer_get_surface (self);
|
|
whole = cairo_region_create_rectangle (&(cairo_rectangle_int_t) {
|
|
0, 0,
|
|
gdk_surface_get_width (surface),
|
|
gdk_surface_get_height (surface)
|
|
});
|
|
gdk_surface_begin_draw_frame (surface, NULL, whole);
|
|
cairo_region_destroy (whole);
|
|
|
|
nodes = g_array_new (FALSE, FALSE, sizeof(guint32));
|
|
node_textures = g_ptr_array_new_with_free_func (g_object_unref);
|
|
gsk_broadway_renderer_add_node (self, nodes, node_textures, root, 0, 0);
|
|
gdk_broadway_surface_set_nodes (surface, nodes, node_textures);
|
|
g_array_unref (nodes);
|
|
g_ptr_array_unref (node_textures);
|
|
|
|
gdk_surface_end_draw_frame (surface);
|
|
}
|
|
|
|
static void
|
|
gsk_broadway_renderer_class_init (GskBroadwayRendererClass *klass)
|
|
{
|
|
GskRendererClass *renderer_class = GSK_RENDERER_CLASS (klass);
|
|
|
|
renderer_class->realize = gsk_broadway_renderer_realize;
|
|
renderer_class->unrealize = gsk_broadway_renderer_unrealize;
|
|
renderer_class->render = gsk_broadway_renderer_render;
|
|
renderer_class->render_texture = gsk_broadway_renderer_render_texture;
|
|
}
|
|
|
|
static void
|
|
gsk_broadway_renderer_init (GskBroadwayRenderer *self)
|
|
{
|
|
}
|