<MACRO>
<NAME>GSK_TYPE_CAIRO_RENDERER</NAME>
#define GSK_TYPE_CAIRO_RENDERER (gsk_cairo_renderer_get_type ())
</MACRO>
<MACRO>
<NAME>GSK_CAIRO_RENDERER</NAME>
#define GSK_CAIRO_RENDERER(obj)                 (G_TYPE_CHECK_INSTANCE_CAST ((obj), GSK_TYPE_CAIRO_RENDERER, GskCairoRenderer))
</MACRO>
<MACRO>
<NAME>GSK_IS_CAIRO_RENDERER</NAME>
#define GSK_IS_CAIRO_RENDERER(obj)              (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GSK_TYPE_CAIRO_RENDERER))
</MACRO>
<MACRO>
<NAME>GSK_CAIRO_RENDERER_CLASS</NAME>
#define GSK_CAIRO_RENDERER_CLASS(klass)         (G_TYPE_CHECK_CLASS_CAST ((klass), GSK_TYPE_CAIRO_RENDERER, GskCairoRendererClass))
</MACRO>
<MACRO>
<NAME>GSK_IS_CAIRO_RENDERER_CLASS</NAME>
#define GSK_IS_CAIRO_RENDERER_CLASS(klass)      (G_TYPE_CHECK_CLASS_TYPE ((klass), GSK_TYPE_CAIRO_RENDERER))
</MACRO>
<MACRO>
<NAME>GSK_CAIRO_RENDERER_GET_CLASS</NAME>
#define GSK_CAIRO_RENDERER_GET_CLASS(obj)       (G_TYPE_INSTANCE_GET_CLASS ((obj), GSK_TYPE_CAIRO_RENDERER, GskCairoRendererClass))
</MACRO>
<FUNCTION>
<NAME>gsk_cairo_renderer_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gsk_cairo_renderer_new</NAME>
<RETURNS>GskRenderer *</RETURNS>
void
</FUNCTION>
<STRUCT>
<NAME>GskCairoRenderer</NAME>
</STRUCT>
<STRUCT>
<NAME>GskCairoRendererClass</NAME>
</STRUCT>
<ENUM>
<NAME>GskDiffResult</NAME>
typedef enum {
  GSK_DIFF_OK = 0,
  GSK_DIFF_ABORTED,
} GskDiffResult;
</ENUM>
<USER_FUNCTION>
<NAME>GskKeepFunc</NAME>
<RETURNS>void</RETURNS>
gconstpointer elem1, gconstpointer elem2, gpointer data
</USER_FUNCTION>
<USER_FUNCTION>
<NAME>GskDeleteFunc</NAME>
<RETURNS>void</RETURNS>
gconstpointer elem, gsize idx, gpointer data
</USER_FUNCTION>
<USER_FUNCTION>
<NAME>GskInsertFunc</NAME>
<RETURNS>void</RETURNS>
gconstpointer elem, gsize idx, gpointer data
</USER_FUNCTION>
<FUNCTION>
<NAME>gsk_diff_settings_new</NAME>
<RETURNS>GskDiffSettings *</RETURNS>
GCompareDataFunc        compare_func, GskKeepFunc             keep_func, GskDeleteFunc           delete_func, GskInsertFunc           insert_func
</FUNCTION>
<FUNCTION>
<NAME>gsk_diff_settings_free</NAME>
<RETURNS>void</RETURNS>
GskDiffSettings        *settings
</FUNCTION>
<FUNCTION>
<NAME>gsk_diff_settings_set_allow_abort</NAME>
<RETURNS>void</RETURNS>
GskDiffSettings        *settings, gboolean                allow_abort
</FUNCTION>
<FUNCTION>
<NAME>gsk_diff</NAME>
<RETURNS>GskDiffResult</RETURNS>
gconstpointer          *elem1, gsize                   n1, gconstpointer          *elem2, gsize                   n2, const GskDiffSettings  *settings, gpointer                data
</FUNCTION>
<STRUCT>
<NAME>GskDiffSettings</NAME>
</STRUCT>
<ENUM>
<NAME>GskRenderNodeType</NAME>
typedef enum {
  GSK_NOT_A_RENDER_NODE = 0,
  GSK_CONTAINER_NODE,
  GSK_CAIRO_NODE,
  GSK_COLOR_NODE,
  GSK_LINEAR_GRADIENT_NODE,
  GSK_REPEATING_LINEAR_GRADIENT_NODE,
  GSK_BORDER_NODE,
  GSK_TEXTURE_NODE,
  GSK_INSET_SHADOW_NODE,
  GSK_OUTSET_SHADOW_NODE,
  GSK_TRANSFORM_NODE,
  GSK_OPACITY_NODE,
  GSK_COLOR_MATRIX_NODE,
  GSK_REPEAT_NODE,
  GSK_CLIP_NODE,
  GSK_ROUNDED_CLIP_NODE,
  GSK_SHADOW_NODE,
  GSK_BLEND_NODE,
  GSK_CROSS_FADE_NODE,
  GSK_TEXT_NODE,
  GSK_BLUR_NODE,
  GSK_DEBUG_NODE
} GskRenderNodeType;
</ENUM>
<ENUM>
<NAME>GskScalingFilter</NAME>
typedef enum {
  GSK_SCALING_FILTER_LINEAR,
  GSK_SCALING_FILTER_NEAREST,
  GSK_SCALING_FILTER_TRILINEAR
} GskScalingFilter;
</ENUM>
<ENUM>
<NAME>GskBlendMode</NAME>
typedef enum {
  GSK_BLEND_MODE_DEFAULT = 0,

  GSK_BLEND_MODE_MULTIPLY,
  GSK_BLEND_MODE_SCREEN,
  GSK_BLEND_MODE_OVERLAY,
  GSK_BLEND_MODE_DARKEN,
  GSK_BLEND_MODE_LIGHTEN,
  GSK_BLEND_MODE_COLOR_DODGE,
  GSK_BLEND_MODE_COLOR_BURN,
  GSK_BLEND_MODE_HARD_LIGHT,
  GSK_BLEND_MODE_SOFT_LIGHT,
  GSK_BLEND_MODE_DIFFERENCE,
  GSK_BLEND_MODE_EXCLUSION,
  GSK_BLEND_MODE_COLOR,
  GSK_BLEND_MODE_HUE,
  GSK_BLEND_MODE_SATURATION,
  GSK_BLEND_MODE_LUMINOSITY
} GskBlendMode;
</ENUM>
<ENUM>
<NAME>GskCorner</NAME>
typedef enum {
  GSK_CORNER_TOP_LEFT,
  GSK_CORNER_TOP_RIGHT,
  GSK_CORNER_BOTTOM_RIGHT,
  GSK_CORNER_BOTTOM_LEFT
} GskCorner;
</ENUM>
<ENUM>
<NAME>GskSerializationError</NAME>
typedef enum {
  GSK_SERIALIZATION_UNSUPPORTED_FORMAT,
  GSK_SERIALIZATION_UNSUPPORTED_VERSION,
  GSK_SERIALIZATION_INVALID_DATA
} GskSerializationError;
</ENUM>
<ENUM>
<NAME>GskTransformCategory</NAME>
typedef enum
{
  GSK_TRANSFORM_CATEGORY_UNKNOWN,
  GSK_TRANSFORM_CATEGORY_ANY,
  GSK_TRANSFORM_CATEGORY_3D,
  GSK_TRANSFORM_CATEGORY_2D,
  GSK_TRANSFORM_CATEGORY_2D_AFFINE,
  GSK_TRANSFORM_CATEGORY_2D_TRANSLATE,
  GSK_TRANSFORM_CATEGORY_IDENTITY
} GskTransformCategory;
</ENUM>
<MACRO>
<NAME>GSK_TYPE_RENDERER</NAME>
#define GSK_TYPE_RENDERER (gsk_renderer_get_type ())
</MACRO>
<MACRO>
<NAME>GSK_RENDERER</NAME>
#define GSK_RENDERER(obj)               (G_TYPE_CHECK_INSTANCE_CAST ((obj), GSK_TYPE_RENDERER, GskRenderer))
</MACRO>
<MACRO>
<NAME>GSK_IS_RENDERER</NAME>
#define GSK_IS_RENDERER(obj)            (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GSK_TYPE_RENDERER))
</MACRO>
<FUNCTION>
<NAME>gsk_renderer_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gsk_renderer_new_for_surface</NAME>
<RETURNS>GskRenderer *</RETURNS>
GdkSurface               *surface
</FUNCTION>
<FUNCTION>
<NAME>gsk_renderer_get_surface</NAME>
<RETURNS>GdkSurface *</RETURNS>
GskRenderer             *renderer
</FUNCTION>
<FUNCTION>
<NAME>gsk_renderer_realize</NAME>
<RETURNS>gboolean</RETURNS>
GskRenderer             *renderer, GdkSurface              *surface, GError                 **error
</FUNCTION>
<FUNCTION>
<NAME>gsk_renderer_unrealize</NAME>
<RETURNS>void</RETURNS>
GskRenderer             *renderer
</FUNCTION>
<FUNCTION>
<NAME>gsk_renderer_is_realized</NAME>
<RETURNS>gboolean</RETURNS>
GskRenderer             *renderer
</FUNCTION>
<FUNCTION>
<NAME>gsk_renderer_render_texture</NAME>
<RETURNS>GdkTexture *</RETURNS>
GskRenderer             *renderer, GskRenderNode           *root, const graphene_rect_t   *viewport
</FUNCTION>
<FUNCTION>
<NAME>gsk_renderer_render</NAME>
<RETURNS>void</RETURNS>
GskRenderer             *renderer, GskRenderNode           *root, const cairo_region_t    *region
</FUNCTION>
<STRUCT>
<NAME>GskRendererClass</NAME>
</STRUCT>
<MACRO>
<NAME>GSK_TYPE_RENDER_NODE</NAME>
#define GSK_TYPE_RENDER_NODE (gsk_render_node_get_type ())
</MACRO>
<MACRO>
<NAME>GSK_IS_RENDER_NODE</NAME>
#define GSK_IS_RENDER_NODE(obj) ((obj) != NULL)
</MACRO>
<MACRO>
<NAME>GSK_SERIALIZATION_ERROR</NAME>
#define GSK_SERIALIZATION_ERROR       (gsk_serialization_error_quark ())
</MACRO>
<STRUCT>
<NAME>GskColorStop</NAME>
struct _GskColorStop
{
  float offset;
  GdkRGBA color;
};
</STRUCT>
<STRUCT>
<NAME>GskShadow</NAME>
struct _GskShadow
{
  GdkRGBA color;
  float dx;
  float dy;
  float radius;
};
</STRUCT>
<USER_FUNCTION>
<NAME>GskParseErrorFunc</NAME>
<RETURNS>void</RETURNS>
const GtkCssSection *section, const GError        *error, gpointer             user_data
</USER_FUNCTION>
<FUNCTION>
<NAME>gsk_render_node_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gsk_serialization_error_quark</NAME>
<RETURNS>GQuark</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gsk_render_node_ref</NAME>
<RETURNS>GskRenderNode *</RETURNS>
GskRenderNode *node
</FUNCTION>
<FUNCTION>
<NAME>gsk_render_node_unref</NAME>
<RETURNS>void</RETURNS>
GskRenderNode *node
</FUNCTION>
<FUNCTION>
<NAME>gsk_render_node_get_node_type</NAME>
<RETURNS>GskRenderNodeType</RETURNS>
GskRenderNode *node
</FUNCTION>
<FUNCTION>
<NAME>gsk_render_node_get_bounds</NAME>
<RETURNS>void</RETURNS>
GskRenderNode   *node, graphene_rect_t *bounds
</FUNCTION>
<FUNCTION>
<NAME>gsk_render_node_draw</NAME>
<RETURNS>void</RETURNS>
GskRenderNode *node, cairo_t       *cr
</FUNCTION>
<FUNCTION>
<NAME>gsk_render_node_serialize</NAME>
<RETURNS>GBytes *</RETURNS>
GskRenderNode *node
</FUNCTION>
<FUNCTION>
<NAME>gsk_render_node_write_to_file</NAME>
<RETURNS>gboolean</RETURNS>
GskRenderNode *node, const char    *filename, GError       **error
</FUNCTION>
<FUNCTION>
<NAME>gsk_render_node_deserialize</NAME>
<RETURNS>GskRenderNode *</RETURNS>
GBytes            *bytes, GskParseErrorFunc  error_func, gpointer           user_data
</FUNCTION>
<MACRO>
<NAME>GSK_TYPE_DEBUG_NODE</NAME>
#define GSK_TYPE_DEBUG_NODE                     (gsk_debug_node_get_type())
</MACRO>
<MACRO>
<NAME>GSK_TYPE_COLOR_NODE</NAME>
#define GSK_TYPE_COLOR_NODE                     (gsk_color_node_get_type())
</MACRO>
<MACRO>
<NAME>GSK_TYPE_TEXTURE_NODE</NAME>
#define GSK_TYPE_TEXTURE_NODE                   (gsk_texture_node_get_type())
</MACRO>
<MACRO>
<NAME>GSK_TYPE_LINEAR_GRADIENT_NODE</NAME>
#define GSK_TYPE_LINEAR_GRADIENT_NODE           (gsk_linear_gradient_node_get_type())
</MACRO>
<MACRO>
<NAME>GSK_TYPE_REPEATING_LINEAR_GRADIENT_NODE</NAME>
#define GSK_TYPE_REPEATING_LINEAR_GRADIENT_NODE (gsk_repeating_linear_gradient_node_get_type())
</MACRO>
<MACRO>
<NAME>GSK_TYPE_BORDER_NODE</NAME>
#define GSK_TYPE_BORDER_NODE                    (gsk_border_node_get_type())
</MACRO>
<MACRO>
<NAME>GSK_TYPE_INSET_SHADOW_NODE</NAME>
#define GSK_TYPE_INSET_SHADOW_NODE              (gsk_inset_shadow_node_get_type())
</MACRO>
<MACRO>
<NAME>GSK_TYPE_OUTSET_SHADOW_NODE</NAME>
#define GSK_TYPE_OUTSET_SHADOW_NODE             (gsk_outset_shadow_node_get_type())
</MACRO>
<MACRO>
<NAME>GSK_TYPE_CAIRO_NODE</NAME>
#define GSK_TYPE_CAIRO_NODE                     (gsk_cairo_node_get_type())
</MACRO>
<MACRO>
<NAME>GSK_TYPE_CONTAINER_NODE</NAME>
#define GSK_TYPE_CONTAINER_NODE                 (gsk_container_node_get_type())
</MACRO>
<MACRO>
<NAME>GSK_TYPE_TRANSFORM_NODE</NAME>
#define GSK_TYPE_TRANSFORM_NODE                 (gsk_transform_node_get_type())
</MACRO>
<MACRO>
<NAME>GSK_TYPE_OPACITY_NODE</NAME>
#define GSK_TYPE_OPACITY_NODE                   (gsk_opacity_node_get_type())
</MACRO>
<MACRO>
<NAME>GSK_TYPE_COLOR_MATRIX_NODE</NAME>
#define GSK_TYPE_COLOR_MATRIX_NODE              (gsk_color_matrix_node_get_type())
</MACRO>
<MACRO>
<NAME>GSK_TYPE_REPEAT_NODE</NAME>
#define GSK_TYPE_REPEAT_NODE                    (gsk_repeat_node_get_type())
</MACRO>
<MACRO>
<NAME>GSK_TYPE_CLIP_NODE</NAME>
#define GSK_TYPE_CLIP_NODE                      (gsk_clip_node_get_type())
</MACRO>
<MACRO>
<NAME>GSK_TYPE_ROUNDED_CLIP_NODE</NAME>
#define GSK_TYPE_ROUNDED_CLIP_NODE              (gsk_rounded_clip_node_get_type())
</MACRO>
<MACRO>
<NAME>GSK_TYPE_SHADOW_NODE</NAME>
#define GSK_TYPE_SHADOW_NODE                    (gsk_shadow_node_get_type())
</MACRO>
<MACRO>
<NAME>GSK_TYPE_BLEND_NODE</NAME>
#define GSK_TYPE_BLEND_NODE                     (gsk_blend_node_get_type())
</MACRO>
<MACRO>
<NAME>GSK_TYPE_CROSS_FADE_NODE</NAME>
#define GSK_TYPE_CROSS_FADE_NODE                (gsk_cross_fade_node_get_type())
</MACRO>
<MACRO>
<NAME>GSK_TYPE_TEXT_NODE</NAME>
#define GSK_TYPE_TEXT_NODE                      (gsk_text_node_get_type())
</MACRO>
<MACRO>
<NAME>GSK_TYPE_BLUR_NODE</NAME>
#define GSK_TYPE_BLUR_NODE                      (gsk_blur_node_get_type())
</MACRO>
<FUNCTION>
<NAME>gsk_debug_node_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gsk_debug_node_new</NAME>
<RETURNS>GskRenderNode *</RETURNS>
GskRenderNode            *child, char                     *message
</FUNCTION>
<FUNCTION>
<NAME>gsk_debug_node_get_child</NAME>
<RETURNS>GskRenderNode *</RETURNS>
GskRenderNode            *node
</FUNCTION>
<FUNCTION>
<NAME>gsk_debug_node_get_message</NAME>
<RETURNS>const char *</RETURNS>
GskRenderNode            *node
</FUNCTION>
<FUNCTION>
<NAME>gsk_color_node_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gsk_color_node_new</NAME>
<RETURNS>GskRenderNode *</RETURNS>
const GdkRGBA            *rgba, const graphene_rect_t    *bounds
</FUNCTION>
<FUNCTION>
<NAME>gsk_color_node_peek_color</NAME>
<RETURNS>const GdkRGBA *</RETURNS>
GskRenderNode            *node
</FUNCTION>
<FUNCTION>
<NAME>gsk_texture_node_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gsk_texture_node_new</NAME>
<RETURNS>GskRenderNode *</RETURNS>
GdkTexture               *texture, const graphene_rect_t    *bounds
</FUNCTION>
<FUNCTION>
<NAME>gsk_texture_node_get_texture</NAME>
<RETURNS>GdkTexture *</RETURNS>
GskRenderNode            *node
</FUNCTION>
<FUNCTION>
<NAME>gsk_linear_gradient_node_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gsk_linear_gradient_node_new</NAME>
<RETURNS>GskRenderNode *</RETURNS>
const graphene_rect_t    *bounds, const graphene_point_t   *start, const graphene_point_t   *end, const GskColorStop       *color_stops, gsize                     n_color_stops
</FUNCTION>
<FUNCTION>
<NAME>gsk_linear_gradient_node_peek_start</NAME>
<RETURNS>const graphene_point_t *</RETURNS>
GskRenderNode            *node
</FUNCTION>
<FUNCTION>
<NAME>gsk_linear_gradient_node_peek_end</NAME>
<RETURNS>const graphene_point_t *</RETURNS>
GskRenderNode            *node
</FUNCTION>
<FUNCTION>
<NAME>gsk_linear_gradient_node_get_n_color_stops</NAME>
<RETURNS>gsize</RETURNS>
GskRenderNode            *node
</FUNCTION>
<FUNCTION>
<NAME>gsk_linear_gradient_node_peek_color_stops</NAME>
<RETURNS>const GskColorStop *</RETURNS>
GskRenderNode            *node, gsize                    *n_stops
</FUNCTION>
<FUNCTION>
<NAME>gsk_repeating_linear_gradient_node_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gsk_repeating_linear_gradient_node_new</NAME>
<RETURNS>GskRenderNode *</RETURNS>
const graphene_rect_t    *bounds, const graphene_point_t   *start, const graphene_point_t   *end, const GskColorStop       *color_stops, gsize                     n_color_stops
</FUNCTION>
<FUNCTION>
<NAME>gsk_border_node_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gsk_border_node_new</NAME>
<RETURNS>GskRenderNode *</RETURNS>
const GskRoundedRect     *outline, const float               border_width[4], const GdkRGBA             border_color[4]
</FUNCTION>
<FUNCTION>
<NAME>gsk_border_node_peek_outline</NAME>
<RETURNS>const GskRoundedRect *</RETURNS>
GskRenderNode            *node
</FUNCTION>
<FUNCTION>
<NAME>gsk_border_node_peek_widths</NAME>
<RETURNS>const float *</RETURNS>
GskRenderNode            *node
</FUNCTION>
<FUNCTION>
<NAME>gsk_border_node_peek_colors</NAME>
<RETURNS>const GdkRGBA *</RETURNS>
GskRenderNode            *node
</FUNCTION>
<FUNCTION>
<NAME>gsk_inset_shadow_node_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gsk_inset_shadow_node_new</NAME>
<RETURNS>GskRenderNode *</RETURNS>
const GskRoundedRect     *outline, const GdkRGBA            *color, float                     dx, float                     dy, float                     spread, float                     blur_radius
</FUNCTION>
<FUNCTION>
<NAME>gsk_inset_shadow_node_peek_outline</NAME>
<RETURNS>const GskRoundedRect *</RETURNS>
GskRenderNode            *node
</FUNCTION>
<FUNCTION>
<NAME>gsk_inset_shadow_node_peek_color</NAME>
<RETURNS>const GdkRGBA *</RETURNS>
GskRenderNode            *node
</FUNCTION>
<FUNCTION>
<NAME>gsk_inset_shadow_node_get_dx</NAME>
<RETURNS>float</RETURNS>
GskRenderNode            *node
</FUNCTION>
<FUNCTION>
<NAME>gsk_inset_shadow_node_get_dy</NAME>
<RETURNS>float</RETURNS>
GskRenderNode            *node
</FUNCTION>
<FUNCTION>
<NAME>gsk_inset_shadow_node_get_spread</NAME>
<RETURNS>float</RETURNS>
GskRenderNode            *node
</FUNCTION>
<FUNCTION>
<NAME>gsk_inset_shadow_node_get_blur_radius</NAME>
<RETURNS>float</RETURNS>
GskRenderNode            *node
</FUNCTION>
<FUNCTION>
<NAME>gsk_outset_shadow_node_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gsk_outset_shadow_node_new</NAME>
<RETURNS>GskRenderNode *</RETURNS>
const GskRoundedRect     *outline, const GdkRGBA            *color, float                     dx, float                     dy, float                     spread, float                     blur_radius
</FUNCTION>
<FUNCTION>
<NAME>gsk_outset_shadow_node_peek_outline</NAME>
<RETURNS>const GskRoundedRect *</RETURNS>
GskRenderNode            *node
</FUNCTION>
<FUNCTION>
<NAME>gsk_outset_shadow_node_peek_color</NAME>
<RETURNS>const GdkRGBA *</RETURNS>
GskRenderNode            *node
</FUNCTION>
<FUNCTION>
<NAME>gsk_outset_shadow_node_get_dx</NAME>
<RETURNS>float</RETURNS>
GskRenderNode            *node
</FUNCTION>
<FUNCTION>
<NAME>gsk_outset_shadow_node_get_dy</NAME>
<RETURNS>float</RETURNS>
GskRenderNode            *node
</FUNCTION>
<FUNCTION>
<NAME>gsk_outset_shadow_node_get_spread</NAME>
<RETURNS>float</RETURNS>
GskRenderNode            *node
</FUNCTION>
<FUNCTION>
<NAME>gsk_outset_shadow_node_get_blur_radius</NAME>
<RETURNS>float</RETURNS>
GskRenderNode            *node
</FUNCTION>
<FUNCTION>
<NAME>gsk_cairo_node_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gsk_cairo_node_new</NAME>
<RETURNS>GskRenderNode *</RETURNS>
const graphene_rect_t    *bounds
</FUNCTION>
<FUNCTION>
<NAME>gsk_cairo_node_get_draw_context</NAME>
<RETURNS>cairo_t *</RETURNS>
GskRenderNode            *node
</FUNCTION>
<FUNCTION>
<NAME>gsk_cairo_node_peek_surface</NAME>
<RETURNS>cairo_surface_t *</RETURNS>
GskRenderNode            *node
</FUNCTION>
<FUNCTION>
<NAME>gsk_container_node_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gsk_container_node_new</NAME>
<RETURNS>GskRenderNode *</RETURNS>
GskRenderNode           **children, guint                     n_children
</FUNCTION>
<FUNCTION>
<NAME>gsk_container_node_get_n_children</NAME>
<RETURNS>guint</RETURNS>
GskRenderNode            *node
</FUNCTION>
<FUNCTION>
<NAME>gsk_container_node_get_child</NAME>
<RETURNS>GskRenderNode *</RETURNS>
GskRenderNode            *node, guint                     idx
</FUNCTION>
<FUNCTION>
<NAME>gsk_transform_node_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gsk_transform_node_new</NAME>
<RETURNS>GskRenderNode *</RETURNS>
GskRenderNode            *child, GskTransform             *transform
</FUNCTION>
<FUNCTION>
<NAME>gsk_transform_node_get_child</NAME>
<RETURNS>GskRenderNode *</RETURNS>
GskRenderNode            *node
</FUNCTION>
<FUNCTION>
<NAME>gsk_transform_node_get_transform</NAME>
<RETURNS>GskTransform *</RETURNS>
GskRenderNode            *node
</FUNCTION>
<FUNCTION>
<NAME>gsk_opacity_node_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gsk_opacity_node_new</NAME>
<RETURNS>GskRenderNode *</RETURNS>
GskRenderNode            *child, float                     opacity
</FUNCTION>
<FUNCTION>
<NAME>gsk_opacity_node_get_child</NAME>
<RETURNS>GskRenderNode *</RETURNS>
GskRenderNode            *node
</FUNCTION>
<FUNCTION>
<NAME>gsk_opacity_node_get_opacity</NAME>
<RETURNS>float</RETURNS>
GskRenderNode            *node
</FUNCTION>
<FUNCTION>
<NAME>gsk_color_matrix_node_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gsk_color_matrix_node_new</NAME>
<RETURNS>GskRenderNode *</RETURNS>
GskRenderNode            *child, const graphene_matrix_t  *color_matrix, const graphene_vec4_t    *color_offset
</FUNCTION>
<FUNCTION>
<NAME>gsk_color_matrix_node_get_child</NAME>
<RETURNS>GskRenderNode *</RETURNS>
GskRenderNode            *node
</FUNCTION>
<FUNCTION>
<NAME>gsk_color_matrix_node_peek_color_matrix</NAME>
<RETURNS>const graphene_matrix_t *</RETURNS>
GskRenderNode            *node
</FUNCTION>
<FUNCTION>
<NAME>gsk_color_matrix_node_peek_color_offset</NAME>
<RETURNS>const graphene_vec4_t *</RETURNS>
GskRenderNode            *node
</FUNCTION>
<FUNCTION>
<NAME>gsk_repeat_node_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gsk_repeat_node_new</NAME>
<RETURNS>GskRenderNode *</RETURNS>
const graphene_rect_t    *bounds, GskRenderNode            *child, const graphene_rect_t    *child_bounds
</FUNCTION>
<FUNCTION>
<NAME>gsk_repeat_node_get_child</NAME>
<RETURNS>GskRenderNode *</RETURNS>
GskRenderNode            *node
</FUNCTION>
<FUNCTION>
<NAME>gsk_repeat_node_peek_child_bounds</NAME>
<RETURNS>const graphene_rect_t *</RETURNS>
GskRenderNode            *node
</FUNCTION>
<FUNCTION>
<NAME>gsk_clip_node_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gsk_clip_node_new</NAME>
<RETURNS>GskRenderNode *</RETURNS>
GskRenderNode            *child, const graphene_rect_t    *clip
</FUNCTION>
<FUNCTION>
<NAME>gsk_clip_node_get_child</NAME>
<RETURNS>GskRenderNode *</RETURNS>
GskRenderNode            *node
</FUNCTION>
<FUNCTION>
<NAME>gsk_clip_node_peek_clip</NAME>
<RETURNS>const graphene_rect_t *</RETURNS>
GskRenderNode            *node
</FUNCTION>
<FUNCTION>
<NAME>gsk_rounded_clip_node_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gsk_rounded_clip_node_new</NAME>
<RETURNS>GskRenderNode *</RETURNS>
GskRenderNode            *child, const GskRoundedRect     *clip
</FUNCTION>
<FUNCTION>
<NAME>gsk_rounded_clip_node_get_child</NAME>
<RETURNS>GskRenderNode *</RETURNS>
GskRenderNode            *node
</FUNCTION>
<FUNCTION>
<NAME>gsk_rounded_clip_node_peek_clip</NAME>
<RETURNS>const GskRoundedRect *</RETURNS>
GskRenderNode            *node
</FUNCTION>
<FUNCTION>
<NAME>gsk_shadow_node_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gsk_shadow_node_new</NAME>
<RETURNS>GskRenderNode *</RETURNS>
GskRenderNode            *child, const GskShadow          *shadows, gsize                     n_shadows
</FUNCTION>
<FUNCTION>
<NAME>gsk_shadow_node_get_child</NAME>
<RETURNS>GskRenderNode *</RETURNS>
GskRenderNode            *node
</FUNCTION>
<FUNCTION>
<NAME>gsk_shadow_node_peek_shadow</NAME>
<RETURNS>const GskShadow *</RETURNS>
GskRenderNode            *node, gsize                     i
</FUNCTION>
<FUNCTION>
<NAME>gsk_shadow_node_get_n_shadows</NAME>
<RETURNS>gsize</RETURNS>
GskRenderNode            *node
</FUNCTION>
<FUNCTION>
<NAME>gsk_blend_node_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gsk_blend_node_new</NAME>
<RETURNS>GskRenderNode *</RETURNS>
GskRenderNode            *bottom, GskRenderNode            *top, GskBlendMode              blend_mode
</FUNCTION>
<FUNCTION>
<NAME>gsk_blend_node_get_bottom_child</NAME>
<RETURNS>GskRenderNode *</RETURNS>
GskRenderNode            *node
</FUNCTION>
<FUNCTION>
<NAME>gsk_blend_node_get_top_child</NAME>
<RETURNS>GskRenderNode *</RETURNS>
GskRenderNode            *node
</FUNCTION>
<FUNCTION>
<NAME>gsk_blend_node_get_blend_mode</NAME>
<RETURNS>GskBlendMode</RETURNS>
GskRenderNode            *node
</FUNCTION>
<FUNCTION>
<NAME>gsk_cross_fade_node_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gsk_cross_fade_node_new</NAME>
<RETURNS>GskRenderNode *</RETURNS>
GskRenderNode            *start, GskRenderNode            *end, float                     progress
</FUNCTION>
<FUNCTION>
<NAME>gsk_cross_fade_node_get_start_child</NAME>
<RETURNS>GskRenderNode *</RETURNS>
GskRenderNode            *node
</FUNCTION>
<FUNCTION>
<NAME>gsk_cross_fade_node_get_end_child</NAME>
<RETURNS>GskRenderNode *</RETURNS>
GskRenderNode            *node
</FUNCTION>
<FUNCTION>
<NAME>gsk_cross_fade_node_get_progress</NAME>
<RETURNS>float</RETURNS>
GskRenderNode            *node
</FUNCTION>
<FUNCTION>
<NAME>gsk_text_node_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gsk_text_node_new</NAME>
<RETURNS>GskRenderNode *</RETURNS>
PangoFont                *font, PangoGlyphString         *glyphs, const GdkRGBA            *color, const graphene_point_t   *offset
</FUNCTION>
<FUNCTION>
<NAME>gsk_text_node_peek_font</NAME>
<RETURNS>PangoFont *</RETURNS>
GskRenderNode            *node
</FUNCTION>
<FUNCTION>
<NAME>gsk_text_node_has_color_glyphs</NAME>
<RETURNS>gboolean</RETURNS>
GskRenderNode            *node
</FUNCTION>
<FUNCTION>
<NAME>gsk_text_node_get_num_glyphs</NAME>
<RETURNS>guint</RETURNS>
GskRenderNode            *node
</FUNCTION>
<FUNCTION>
<NAME>gsk_text_node_peek_glyphs</NAME>
<RETURNS>const PangoGlyphInfo *</RETURNS>
GskRenderNode            *node, guint                    *n_glyphs
</FUNCTION>
<FUNCTION>
<NAME>gsk_text_node_peek_color</NAME>
<RETURNS>const GdkRGBA *</RETURNS>
GskRenderNode            *node
</FUNCTION>
<FUNCTION>
<NAME>gsk_text_node_get_offset</NAME>
<RETURNS>const graphene_point_t *</RETURNS>
GskRenderNode            *node
</FUNCTION>
<FUNCTION>
<NAME>gsk_blur_node_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gsk_blur_node_new</NAME>
<RETURNS>GskRenderNode *</RETURNS>
GskRenderNode            *child, float                     radius
</FUNCTION>
<FUNCTION>
<NAME>gsk_blur_node_get_child</NAME>
<RETURNS>GskRenderNode *</RETURNS>
GskRenderNode            *node
</FUNCTION>
<FUNCTION>
<NAME>gsk_blur_node_get_radius</NAME>
<RETURNS>float</RETURNS>
GskRenderNode            *node
</FUNCTION>
<STRUCT>
<NAME>GskBlendNode</NAME>
</STRUCT>
<STRUCT>
<NAME>GskBlurNode</NAME>
</STRUCT>
<STRUCT>
<NAME>GskBorderNode</NAME>
</STRUCT>
<STRUCT>
<NAME>GskCairoNode</NAME>
</STRUCT>
<STRUCT>
<NAME>GskClipNode</NAME>
</STRUCT>
<STRUCT>
<NAME>GskColorMatrixNode</NAME>
</STRUCT>
<STRUCT>
<NAME>GskColorNode</NAME>
</STRUCT>
<STRUCT>
<NAME>GskContainerNode</NAME>
</STRUCT>
<STRUCT>
<NAME>GskCrossFadeNode</NAME>
</STRUCT>
<STRUCT>
<NAME>GskDebugNode</NAME>
</STRUCT>
<STRUCT>
<NAME>GskInsetShadowNode</NAME>
</STRUCT>
<STRUCT>
<NAME>GskLinearGradientNode</NAME>
</STRUCT>
<STRUCT>
<NAME>GskOpacityNode</NAME>
</STRUCT>
<STRUCT>
<NAME>GskOutsetShadowNode</NAME>
</STRUCT>
<STRUCT>
<NAME>GskRenderNode</NAME>
</STRUCT>
<STRUCT>
<NAME>GskRepeatNode</NAME>
</STRUCT>
<STRUCT>
<NAME>GskRepeatingLinearGradientNode</NAME>
</STRUCT>
<STRUCT>
<NAME>GskRoundedClipNode</NAME>
</STRUCT>
<STRUCT>
<NAME>GskShadowNode</NAME>
</STRUCT>
<STRUCT>
<NAME>GskTextNode</NAME>
</STRUCT>
<STRUCT>
<NAME>GskTextureNode</NAME>
</STRUCT>
<STRUCT>
<NAME>GskTransformNode</NAME>
</STRUCT>
<MACRO>
<NAME>GSK_ROUNDED_RECT_INIT</NAME>
#define GSK_ROUNDED_RECT_INIT(_x,_y,_w,_h)       (GskRoundedRect) { .bounds = GRAPHENE_RECT_INIT(_x,_y,_w,_h), \
                                                                    .corner = { \
                                                                       GRAPHENE_SIZE_INIT(0, 0),\
                                                                       GRAPHENE_SIZE_INIT(0, 0),\
                                                                       GRAPHENE_SIZE_INIT(0, 0),\
                                                                       GRAPHENE_SIZE_INIT(0, 0),\
                                                                    }}
</MACRO>
<STRUCT>
<NAME>GskRoundedRect</NAME>
struct _GskRoundedRect
{
  graphene_rect_t bounds;

  graphene_size_t corner[4];
};
</STRUCT>
<FUNCTION>
<NAME>gsk_rounded_rect_init</NAME>
<RETURNS>GskRoundedRect *</RETURNS>
GskRoundedRect           *self, const graphene_rect_t    *bounds, const graphene_size_t    *top_left, const graphene_size_t    *top_right, const graphene_size_t    *bottom_right, const graphene_size_t    *bottom_left
</FUNCTION>
<FUNCTION>
<NAME>gsk_rounded_rect_init_copy</NAME>
<RETURNS>GskRoundedRect *</RETURNS>
GskRoundedRect           *self, const GskRoundedRect     *src
</FUNCTION>
<FUNCTION>
<NAME>gsk_rounded_rect_init_from_rect</NAME>
<RETURNS>GskRoundedRect *</RETURNS>
GskRoundedRect           *self, const graphene_rect_t    *bounds, float                     radius
</FUNCTION>
<FUNCTION>
<NAME>gsk_rounded_rect_normalize</NAME>
<RETURNS>GskRoundedRect *</RETURNS>
GskRoundedRect           *self
</FUNCTION>
<FUNCTION>
<NAME>gsk_rounded_rect_offset</NAME>
<RETURNS>GskRoundedRect *</RETURNS>
GskRoundedRect           *self, float                     dx, float                     dy
</FUNCTION>
<FUNCTION>
<NAME>gsk_rounded_rect_shrink</NAME>
<RETURNS>GskRoundedRect *</RETURNS>
GskRoundedRect           *self, float                     top, float                     right, float                     bottom, float                     left
</FUNCTION>
<FUNCTION>
<NAME>gsk_rounded_rect_is_rectilinear</NAME>
<RETURNS>gboolean</RETURNS>
const GskRoundedRect     *self
</FUNCTION>
<FUNCTION>
<NAME>gsk_rounded_rect_contains_point</NAME>
<RETURNS>gboolean</RETURNS>
const GskRoundedRect     *self, const graphene_point_t   *point
</FUNCTION>
<FUNCTION>
<NAME>gsk_rounded_rect_contains_rect</NAME>
<RETURNS>gboolean</RETURNS>
const GskRoundedRect     *self, const graphene_rect_t    *rect
</FUNCTION>
<FUNCTION>
<NAME>gsk_rounded_rect_intersects_rect</NAME>
<RETURNS>gboolean</RETURNS>
const GskRoundedRect     *self, const graphene_rect_t    *rect
</FUNCTION>
<MACRO>
<NAME>GSK_TYPE_TRANSFORM</NAME>
#define GSK_TYPE_TRANSFORM (gsk_transform_get_type ())
</MACRO>
<FUNCTION>
<NAME>gsk_transform_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gsk_transform_ref</NAME>
<RETURNS>GskTransform *</RETURNS>
GskTransform                   *self
</FUNCTION>
<FUNCTION>
<NAME>gsk_transform_unref</NAME>
<RETURNS>void</RETURNS>
GskTransform                   *self
</FUNCTION>
<FUNCTION>
<NAME>gsk_transform_print</NAME>
<RETURNS>void</RETURNS>
GskTransform                   *self, GString                        *string
</FUNCTION>
<FUNCTION>
<NAME>gsk_transform_to_string</NAME>
<RETURNS>char *</RETURNS>
GskTransform                   *self
</FUNCTION>
<FUNCTION>
<NAME>gsk_transform_parse</NAME>
<RETURNS>gboolean</RETURNS>
const char                     *string, GskTransform                  **out_transform
</FUNCTION>
<FUNCTION>
<NAME>gsk_transform_to_matrix</NAME>
<RETURNS>void</RETURNS>
GskTransform                   *self, graphene_matrix_t              *out_matrix
</FUNCTION>
<FUNCTION>
<NAME>gsk_transform_to_2d</NAME>
<RETURNS>void</RETURNS>
GskTransform                   *self, float                          *out_xx, float                          *out_yx, float                          *out_xy, float                          *out_yy, float                          *out_dx, float                          *out_dy
</FUNCTION>
<FUNCTION>
<NAME>gsk_transform_to_affine</NAME>
<RETURNS>void</RETURNS>
GskTransform                   *self, float                          *out_scale_x, float                          *out_scale_y, float                          *out_dx, float                          *out_dy
</FUNCTION>
<FUNCTION>
<NAME>gsk_transform_to_translate</NAME>
<RETURNS>void</RETURNS>
GskTransform                   *self, float                          *out_dx, float                          *out_dy
</FUNCTION>
<FUNCTION>
<NAME>gsk_transform_get_category</NAME>
<RETURNS>GskTransformCategory</RETURNS>
GskTransform                   *self
</FUNCTION>
<FUNCTION>
<NAME>gsk_transform_equal</NAME>
<RETURNS>gboolean</RETURNS>
GskTransform                   *first, GskTransform                   *second
</FUNCTION>
<FUNCTION>
<NAME>gsk_transform_new</NAME>
<RETURNS>GskTransform *</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gsk_transform_transform</NAME>
<RETURNS>GskTransform *</RETURNS>
GskTransform                   *next, GskTransform                   *other
</FUNCTION>
<FUNCTION>
<NAME>gsk_transform_invert</NAME>
<RETURNS>GskTransform *</RETURNS>
GskTransform                   *self
</FUNCTION>
<FUNCTION>
<NAME>gsk_transform_matrix</NAME>
<RETURNS>GskTransform *</RETURNS>
GskTransform                   *next, const graphene_matrix_t        *matrix
</FUNCTION>
<FUNCTION>
<NAME>gsk_transform_translate</NAME>
<RETURNS>GskTransform *</RETURNS>
GskTransform                   *next, const graphene_point_t         *point
</FUNCTION>
<FUNCTION>
<NAME>gsk_transform_translate_3d</NAME>
<RETURNS>GskTransform *</RETURNS>
GskTransform                   *next, const graphene_point3d_t       *point
</FUNCTION>
<FUNCTION>
<NAME>gsk_transform_rotate</NAME>
<RETURNS>GskTransform *</RETURNS>
GskTransform                   *next, float                           angle
</FUNCTION>
<FUNCTION>
<NAME>gsk_transform_rotate_3d</NAME>
<RETURNS>GskTransform *</RETURNS>
GskTransform                   *next, float                           angle, const graphene_vec3_t          *axis
</FUNCTION>
<FUNCTION>
<NAME>gsk_transform_scale</NAME>
<RETURNS>GskTransform *</RETURNS>
GskTransform                   *next, float                           factor_x, float                           factor_y
</FUNCTION>
<FUNCTION>
<NAME>gsk_transform_scale_3d</NAME>
<RETURNS>GskTransform *</RETURNS>
GskTransform                   *next, float                           factor_x, float                           factor_y, float                           factor_z
</FUNCTION>
<FUNCTION>
<NAME>gsk_transform_perspective</NAME>
<RETURNS>GskTransform *</RETURNS>
GskTransform                   *next, float                           depth
</FUNCTION>
<FUNCTION>
<NAME>gsk_transform_transform_bounds</NAME>
<RETURNS>void</RETURNS>
GskTransform                   *self, const graphene_rect_t          *rect, graphene_rect_t                *out_rect
</FUNCTION>
<FUNCTION>
<NAME>gsk_transform_transform_point</NAME>
<RETURNS>void</RETURNS>
GskTransform                   *self, const graphene_point_t          *point, graphene_point_t                *out_point
</FUNCTION>
<STRUCT>
<NAME>GskRenderer</NAME>
</STRUCT>
<STRUCT>
<NAME>GskTransform</NAME>
</STRUCT>
<MACRO>
<NAME>GSK_TYPE_BROADWAY_RENDERER</NAME>
#define GSK_TYPE_BROADWAY_RENDERER (gsk_broadway_renderer_get_type ())
</MACRO>
<MACRO>
<NAME>GSK_BROADWAY_RENDERER</NAME>
#define GSK_BROADWAY_RENDERER(obj)                 (G_TYPE_CHECK_INSTANCE_CAST ((obj), GSK_TYPE_BROADWAY_RENDERER, GskBroadwayRenderer))
</MACRO>
<MACRO>
<NAME>GSK_IS_BROADWAY_RENDERER</NAME>
#define GSK_IS_BROADWAY_RENDERER(obj)              (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GSK_TYPE_BROADWAY_RENDERER))
</MACRO>
<MACRO>
<NAME>GSK_BROADWAY_RENDERER_CLASS</NAME>
#define GSK_BROADWAY_RENDERER_CLASS(klass)         (G_TYPE_CHECK_CLASS_CAST ((klass), GSK_TYPE_BROADWAY_RENDERER, GskBroadwayRendererClass))
</MACRO>
<MACRO>
<NAME>GSK_IS_BROADWAY_RENDERER_CLASS</NAME>
#define GSK_IS_BROADWAY_RENDERER_CLASS(klass)      (G_TYPE_CHECK_CLASS_TYPE ((klass), GSK_TYPE_BROADWAY_RENDERER))
</MACRO>
<MACRO>
<NAME>GSK_BROADWAY_RENDERER_GET_CLASS</NAME>
#define GSK_BROADWAY_RENDERER_GET_CLASS(obj)       (G_TYPE_INSTANCE_GET_CLASS ((obj), GSK_TYPE_BROADWAY_RENDERER, GskBroadwayRendererClass))
</MACRO>
<FUNCTION>
<NAME>gsk_broadway_renderer_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gsk_broadway_renderer_new</NAME>
<RETURNS>GskRenderer *</RETURNS>
void
</FUNCTION>
<STRUCT>
<NAME>GskBroadwayRenderer</NAME>
</STRUCT>
<STRUCT>
<NAME>GskBroadwayRendererClass</NAME>
</STRUCT>
<MACRO>
<NAME>SANITY_CHECKS</NAME>
#define SANITY_CHECKS 0
</MACRO>
<MACRO>
<NAME>rounded_rect_top_left</NAME>
#define rounded_rect_top_left(r) (GRAPHENE_RECT_INIT(r->bounds.origin.x, \
                                                     r->bounds.origin.y, \
                                                     r->corner[0].width, r->corner[0].height))
</MACRO>
<MACRO>
<NAME>rounded_rect_top_right</NAME>
#define rounded_rect_top_right(r) (GRAPHENE_RECT_INIT(r->bounds.origin.x + r->bounds.size.width - r->corner[1].width, \
                                                      r->bounds.origin.y, \
                                                      r->corner[1].width, r->corner[1].height))
</MACRO>
<MACRO>
<NAME>rounded_rect_bottom_right</NAME>
#define rounded_rect_bottom_right(r) (GRAPHENE_RECT_INIT(r->bounds.origin.x + r->bounds.size.width - r->corner[2].width, \
                                                         r->bounds.origin.y + r->bounds.size.height - r->corner[2].height, \
                                                         r->corner[2].width, r->corner[2].height))
</MACRO>
<MACRO>
<NAME>rounded_rect_bottom_left</NAME>
#define rounded_rect_bottom_left(r) (GRAPHENE_RECT_INIT(r->bounds.origin.x, \
                                                         r->bounds.origin.y + r->bounds.size.height - r->corner[2].height, \
                                                         r->corner[3].width, r->corner[3].height))
</MACRO>
<MACRO>
<NAME>rounded_rect_corner0</NAME>
#define rounded_rect_corner0(r) rounded_rect_top_left(r)
</MACRO>
<MACRO>
<NAME>rounded_rect_corner1</NAME>
#define rounded_rect_corner1(r) rounded_rect_top_right(r)
</MACRO>
<MACRO>
<NAME>rounded_rect_corner2</NAME>
#define rounded_rect_corner2(r) rounded_rect_bottom_right(r)
</MACRO>
<MACRO>
<NAME>rounded_rect_corner3</NAME>
#define rounded_rect_corner3(r) rounded_rect_bottom_left(r)
</MACRO>
<MACRO>
<NAME>rounded_rect_corner</NAME>
#define rounded_rect_corner(r, i) (rounded_rect_corner ##i(r))
</MACRO>
<MACRO>
<NAME>graphene_size_non_zero</NAME>
#define graphene_size_non_zero(s) (s->width > 0 && s->height > 0)
</MACRO>
<MACRO>
<NAME>rounded_rect_has_corner</NAME>
#define rounded_rect_has_corner(r, i) (r->corner[i].width > 0 && r->corner[i].height > 0)
</MACRO>
<MACRO>
<NAME>rect_contains_point</NAME>
#define rect_contains_point(r, _x, _y) (_x >= (r)->origin.x && _x <= (r)->origin.x + (r)->size.width && \
                                        _y >= (r)->origin.y && _y <= (r)->origin.y + (r)->size.height)
</MACRO>
<MACRO>
<NAME>NINE_SLICE_SIZE</NAME>
#define NINE_SLICE_SIZE 9 /* Hah. */
</MACRO>
<FUNCTION>
<NAME>nine_slice_rounded_rect</NAME>
<RETURNS>void</RETURNS>
const GskRoundedRect  *rect, cairo_rectangle_int_t *out_rects
</FUNCTION>
<FUNCTION>
<NAME>nine_slice_grow</NAME>
<RETURNS>void</RETURNS>
cairo_rectangle_int_t *slices, const int              amount
</FUNCTION>
<FUNCTION>
<NAME>nine_slice_to_texture_coords</NAME>
<RETURNS>void</RETURNS>
const cairo_rectangle_int_t *slices, const int                    texture_width, const int                    texture_height, TextureRegion               *out_regions
</FUNCTION>
<MACRO>
<NAME>GSK_TYPE_GL_DRIVER</NAME>
#define GSK_TYPE_GL_DRIVER (gsk_gl_driver_get_type ())
</MACRO>
<STRUCT>
<NAME>GskQuadVertex</NAME>
typedef struct {
  float position[2];
  float uv[2];
} GskQuadVertex;
</STRUCT>
<STRUCT>
<NAME>TextureSlice</NAME>
typedef struct {
  cairo_rectangle_int_t rect;
  guint texture_id;
} TextureSlice;
</STRUCT>
<FUNCTION>
<NAME>gsk_gl_driver_new</NAME>
<RETURNS>GskGLDriver *</RETURNS>
GdkGLContext    *context
</FUNCTION>
<FUNCTION>
<NAME>gsk_gl_driver_get_gl_context</NAME>
<RETURNS>GdkGLContext *</RETURNS>
GskGLDriver     *driver
</FUNCTION>
<FUNCTION>
<NAME>gsk_gl_driver_get_max_texture_size</NAME>
<RETURNS>int</RETURNS>
GskGLDriver     *driver
</FUNCTION>
<FUNCTION>
<NAME>gsk_gl_driver_begin_frame</NAME>
<RETURNS>void</RETURNS>
GskGLDriver     *driver
</FUNCTION>
<FUNCTION>
<NAME>gsk_gl_driver_end_frame</NAME>
<RETURNS>void</RETURNS>
GskGLDriver     *driver
</FUNCTION>
<FUNCTION>
<NAME>gsk_gl_driver_in_frame</NAME>
<RETURNS>gboolean</RETURNS>
GskGLDriver     *driver
</FUNCTION>
<FUNCTION>
<NAME>gsk_gl_driver_get_texture_for_texture</NAME>
<RETURNS>int</RETURNS>
GskGLDriver     *driver, GdkTexture      *texture, int              min_filter, int              mag_filter
</FUNCTION>
<FUNCTION>
<NAME>gsk_gl_driver_get_texture_for_pointer</NAME>
<RETURNS>int</RETURNS>
GskGLDriver     *driver, gpointer         pointer
</FUNCTION>
<FUNCTION>
<NAME>gsk_gl_driver_set_texture_for_pointer</NAME>
<RETURNS>void</RETURNS>
GskGLDriver     *driver, gpointer         pointer, int              texture_id
</FUNCTION>
<FUNCTION>
<NAME>gsk_gl_driver_create_texture</NAME>
<RETURNS>int</RETURNS>
GskGLDriver     *driver, float            width, float            height
</FUNCTION>
<FUNCTION>
<NAME>gsk_gl_driver_create_render_target</NAME>
<RETURNS>void</RETURNS>
GskGLDriver     *driver, int              width, int              height, int             *out_texture_id, int             *out_render_target_id
</FUNCTION>
<FUNCTION>
<NAME>gsk_gl_driver_mark_texture_permanent</NAME>
<RETURNS>void</RETURNS>
GskGLDriver     *self, int              texture_id
</FUNCTION>
<FUNCTION>
<NAME>gsk_gl_driver_bind_source_texture</NAME>
<RETURNS>void</RETURNS>
GskGLDriver     *driver, int              texture_id
</FUNCTION>
<FUNCTION>
<NAME>gsk_gl_driver_init_texture_empty</NAME>
<RETURNS>void</RETURNS>
GskGLDriver     *driver, int              texture_id, int              min_filter, int              max_filter
</FUNCTION>
<FUNCTION>
<NAME>gsk_gl_driver_init_texture_with_surface</NAME>
<RETURNS>void</RETURNS>
GskGLDriver     *driver, int              texture_id, cairo_surface_t *surface, int              min_filter, int              mag_filter
</FUNCTION>
<FUNCTION>
<NAME>gsk_gl_driver_destroy_texture</NAME>
<RETURNS>void</RETURNS>
GskGLDriver     *driver, int              texture_id
</FUNCTION>
<FUNCTION>
<NAME>gsk_gl_driver_collect_textures</NAME>
<RETURNS>int</RETURNS>
GskGLDriver     *driver
</FUNCTION>
<FUNCTION>
<NAME>gsk_gl_driver_slice_texture</NAME>
<RETURNS>void</RETURNS>
GskGLDriver     *self, GdkTexture      *texture, TextureSlice   **out_slices, guint           *out_n_slices
</FUNCTION>
<STRUCT>
<NAME>GskGLDriver</NAME>
</STRUCT>
<STRUCT>
<NAME>CacheKeyData</NAME>
struct _CacheKeyData
{
  PangoFont *font;
  PangoGlyph glyph;
  guint xshift : 3;
  guint yshift : 3;
  guint scale  : 26; /* times 1024 */
};
</STRUCT>
<STRUCT>
<NAME>GlyphCacheKey</NAME>
struct _GlyphCacheKey
{
  CacheKeyData data;
  guint hash;
};
</STRUCT>
<MACRO>
<NAME>PHASE</NAME>
#define PHASE(x) ((int)(floor (4 * (x + 0.125)) - 4 * floor (x + 0.125)))
</MACRO>
<FUNCTION>
<NAME>glyph_cache_key_set_glyph_and_shift</NAME>
<RETURNS>void</RETURNS>
GlyphCacheKey *key, PangoGlyph glyph, float x, float y
</FUNCTION>
<STRUCT>
<NAME>GskGLCachedGlyph</NAME>
struct _GskGLCachedGlyph
{
  GskGLTextureAtlas *atlas;
  guint texture_id;

  float tx;
  float ty;
  float tw;
  float th;

  int draw_x;
  int draw_y;
  int draw_width;
  int draw_height;

  guint accessed : 1; /* accessed since last check */
  guint used     : 1; /* accounted as used in the atlas */
};
</STRUCT>
<FUNCTION>
<NAME>gsk_gl_glyph_cache_new</NAME>
<RETURNS>GskGLGlyphCache *</RETURNS>
GdkDisplay *display, GskGLTextureAtlases *atlases
</FUNCTION>
<FUNCTION>
<NAME>gsk_gl_glyph_cache_ref</NAME>
<RETURNS>GskGLGlyphCache *</RETURNS>
GskGLGlyphCache *self
</FUNCTION>
<FUNCTION>
<NAME>gsk_gl_glyph_cache_unref</NAME>
<RETURNS>void</RETURNS>
GskGLGlyphCache        *self
</FUNCTION>
<FUNCTION>
<NAME>gsk_gl_glyph_cache_begin_frame</NAME>
<RETURNS>void</RETURNS>
GskGLGlyphCache        *self, GskGLDriver            *driver, GPtrArray              *removed_atlases
</FUNCTION>
<FUNCTION>
<NAME>gsk_gl_glyph_cache_lookup_or_add</NAME>
<RETURNS>void</RETURNS>
GskGLGlyphCache        *self, GlyphCacheKey          *lookup, GskGLDriver            *driver, const GskGLCachedGlyph **cached_glyph_out
</FUNCTION>
<STRUCT>
<NAME>CacheKeyData</NAME>
</STRUCT>
<STRUCT>
<NAME>GlyphCacheKey</NAME>
</STRUCT>
<FUNCTION>
<NAME>gsk_gl_icon_cache_new</NAME>
<RETURNS>GskGLIconCache *</RETURNS>
GdkDisplay *display, GskGLTextureAtlases *atlases
</FUNCTION>
<FUNCTION>
<NAME>gsk_gl_icon_cache_ref</NAME>
<RETURNS>GskGLIconCache *</RETURNS>
GskGLIconCache        *self
</FUNCTION>
<FUNCTION>
<NAME>gsk_gl_icon_cache_unref</NAME>
<RETURNS>void</RETURNS>
GskGLIconCache        *self
</FUNCTION>
<FUNCTION>
<NAME>gsk_gl_icon_cache_begin_frame</NAME>
<RETURNS>void</RETURNS>
GskGLIconCache        *self, GPtrArray             *removed_atlases
</FUNCTION>
<FUNCTION>
<NAME>gsk_gl_icon_cache_lookup_or_add</NAME>
<RETURNS>void</RETURNS>
GskGLIconCache        *self, GdkTexture            *texture, const IconData       **out_icon_data
</FUNCTION>
<FUNCTION>
<NAME>gsk_gl_image_create</NAME>
<RETURNS>void</RETURNS>
GskGLImage           *self, GskGLDriver          *gl_driver, int                   width, int                   height, int                   min_filter, int                   mag_filter
</FUNCTION>
<FUNCTION>
<NAME>gsk_gl_image_destroy</NAME>
<RETURNS>void</RETURNS>
GskGLImage           *self, GskGLDriver          *gl_driver
</FUNCTION>
<FUNCTION>
<NAME>gsk_gl_image_write_to_png</NAME>
<RETURNS>void</RETURNS>
const GskGLImage     *self, GskGLDriver          *gl_driver, const char           *filename
</FUNCTION>
<FUNCTION>
<NAME>gsk_gl_image_upload_region</NAME>
<RETURNS>void</RETURNS>
GskGLImage           *self, GskGLDriver          *gl_driver, const GskImageRegion *region
</FUNCTION>
<MACRO>
<NAME>N_NODE_TYPES</NAME>
#define N_NODE_TYPES (GSK_DEBUG_NODE + 1)
</MACRO>
<FUNCTION>
<NAME>node_sample_init</NAME>
<RETURNS>void</RETURNS>
NodeSample       *self
</FUNCTION>
<FUNCTION>
<NAME>node_sample_reset</NAME>
<RETURNS>void</RETURNS>
NodeSample       *self
</FUNCTION>
<FUNCTION>
<NAME>node_sample_add</NAME>
<RETURNS>void</RETURNS>
NodeSample       *self, GskRenderNode    *node
</FUNCTION>
<FUNCTION>
<NAME>node_sample_print</NAME>
<RETURNS>void</RETURNS>
const NodeSample *self, const char       *prefix
</FUNCTION>
<MACRO>
<NAME>GSK_TYPE_GL_PROFILER</NAME>
#define GSK_TYPE_GL_PROFILER (gsk_gl_profiler_get_type ())
</MACRO>
<FUNCTION>
<NAME>gsk_gl_profiler_new</NAME>
<RETURNS>GskGLProfiler *</RETURNS>
GdkGLContext  *context
</FUNCTION>
<FUNCTION>
<NAME>gsk_gl_profiler_begin_gpu_region</NAME>
<RETURNS>void</RETURNS>
GskGLProfiler *profiler
</FUNCTION>
<FUNCTION>
<NAME>gsk_gl_profiler_end_gpu_region</NAME>
<RETURNS>guint64</RETURNS>
GskGLProfiler *profiler
</FUNCTION>
<STRUCT>
<NAME>GskGLProfiler</NAME>
</STRUCT>
<MACRO>
<NAME>GSK_TYPE_GL_RENDERER</NAME>
#define GSK_TYPE_GL_RENDERER (gsk_gl_renderer_get_type ())
</MACRO>
<MACRO>
<NAME>GSK_GL_RENDERER</NAME>
#define GSK_GL_RENDERER(obj)                    (G_TYPE_CHECK_INSTANCE_CAST ((obj), GSK_TYPE_GL_RENDERER, GskGLRenderer))
</MACRO>
<MACRO>
<NAME>GSK_IS_GL_RENDERER</NAME>
#define GSK_IS_GL_RENDERER(obj)                 (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GSK_TYPE_GL_RENDERER))
</MACRO>
<MACRO>
<NAME>GSK_GL_RENDERER_CLASS</NAME>
#define GSK_GL_RENDERER_CLASS(klass)            (G_TYPE_CHECK_CLASS_CAST ((klass), GSK_TYPE_GL_RENDERER, GskGLRendererClass))
</MACRO>
<MACRO>
<NAME>GSK_IS_GL_RENDERER_CLASS</NAME>
#define GSK_IS_GL_RENDERER_CLASS(klass)         (G_TYPE_CHECK_CLASS_TYPE ((klass), GSK_TYPE_GL_RENDERER))
</MACRO>
<MACRO>
<NAME>GSK_GL_RENDERER_GET_CLASS</NAME>
#define GSK_GL_RENDERER_GET_CLASS(obj)          (G_TYPE_INSTANCE_GET_CLASS ((obj), GSK_TYPE_GL_RENDERER, GskGLRendererClass))
</MACRO>
<FUNCTION>
<NAME>gsk_gl_renderer_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gsk_gl_renderer_new</NAME>
<RETURNS>GskRenderer *</RETURNS>
void
</FUNCTION>
<STRUCT>
<NAME>GskGLRenderer</NAME>
</STRUCT>
<STRUCT>
<NAME>GskGLRendererClass</NAME>
</STRUCT>
<MACRO>
<NAME>GL_N_VERTICES</NAME>
#define GL_N_VERTICES 6
</MACRO>
<MACRO>
<NAME>GL_N_PROGRAMS</NAME>
#define GL_N_PROGRAMS 13
</MACRO>
<MACRO>
<NAME>MAX_GRADIENT_STOPS</NAME>
#define MAX_GRADIENT_STOPS 8
</MACRO>
<STRUCT>
<NAME>Program</NAME>
struct _Program
{
  int index;        /* Into the renderer's program array */

  int id;
  /* Common locations (gl_common)*/
  int source_location;
  int position_location;
  int uv_location;
  int alpha_location;
  int viewport_location;
  int projection_location;
  int modelview_location;
  int clip_rect_location;
  union {
    struct {
      int color_location;
    } color;
    struct {
      int color_location;
    } coloring;
    struct {
      int color_matrix_location;
      int color_offset_location;
    } color_matrix;
    struct {
      int num_color_stops_location;
      int color_stops_location;
      int start_point_location;
      int end_point_location;
    } linear_gradient;
    struct {
      int blur_radius_location;
      int blur_size_location;
      int blur_dir_location;
    } blur;
    struct {
      int color_location;
      int spread_location;
      int offset_location;
      int outline_rect_location;
    } inset_shadow;
    struct {
      int color_location;
      int outline_rect_location;
    } outset_shadow;
    struct {
      int outline_rect_location;
      int color_location;
      int spread_location;
      int offset_location;
    } unblurred_outset_shadow;
    struct {
      int color_location;
      int widths_location;
      int outline_rect_location;
    } border;
    struct {
      int source2_location;
      int progress_location;
    } cross_fade;
    struct {
      int source2_location;
      int mode_location;
    } blend;
    struct {
      int child_bounds_location;
      int texture_rect_location;
    } repeat;
  };
};
</STRUCT>
<STRUCT>
<NAME>GskGLRendererPrograms</NAME>
typedef struct {
  int ref_count;
  union {
    Program programs[GL_N_PROGRAMS];
    struct {
      Program blend_program;
      Program blit_program;
      Program blur_program;
      Program border_program;
      Program color_matrix_program;
      Program color_program;
      Program coloring_program;
      Program cross_fade_program;
      Program inset_shadow_program;
      Program linear_gradient_program;
      Program outset_shadow_program;
      Program repeat_program;
      Program unblurred_outset_shadow_program;
    };
  };
  ProgramState state[GL_N_PROGRAMS];
} GskGLRendererPrograms;
</STRUCT>
<FUNCTION>
<NAME>ops_dump_framebuffer</NAME>
<RETURNS>void</RETURNS>
RenderOpBuilder         *builder, const char              *filename, int                      width, int                      height
</FUNCTION>
<FUNCTION>
<NAME>ops_init</NAME>
<RETURNS>void</RETURNS>
RenderOpBuilder         *builder
</FUNCTION>
<FUNCTION>
<NAME>ops_free</NAME>
<RETURNS>void</RETURNS>
RenderOpBuilder         *builder
</FUNCTION>
<FUNCTION>
<NAME>ops_reset</NAME>
<RETURNS>void</RETURNS>
RenderOpBuilder         *builder
</FUNCTION>
<FUNCTION>
<NAME>ops_push_debug_group</NAME>
<RETURNS>void</RETURNS>
RenderOpBuilder         *builder, const char              *text
</FUNCTION>
<FUNCTION>
<NAME>ops_pop_debug_group</NAME>
<RETURNS>void</RETURNS>
RenderOpBuilder         *builder
</FUNCTION>
<FUNCTION>
<NAME>ops_finish</NAME>
<RETURNS>void</RETURNS>
RenderOpBuilder         *builder
</FUNCTION>
<FUNCTION>
<NAME>ops_push_modelview</NAME>
<RETURNS>void</RETURNS>
RenderOpBuilder         *builder, GskTransform            *transform
</FUNCTION>
<FUNCTION>
<NAME>ops_set_modelview</NAME>
<RETURNS>void</RETURNS>
RenderOpBuilder         *builder, GskTransform            *transform
</FUNCTION>
<FUNCTION>
<NAME>ops_pop_modelview</NAME>
<RETURNS>void</RETURNS>
RenderOpBuilder         *builder
</FUNCTION>
<FUNCTION>
<NAME>ops_get_scale</NAME>
<RETURNS>float</RETURNS>
const RenderOpBuilder   *builder
</FUNCTION>
<FUNCTION>
<NAME>ops_set_program</NAME>
<RETURNS>void</RETURNS>
RenderOpBuilder         *builder, const Program           *program
</FUNCTION>
<FUNCTION>
<NAME>ops_push_clip</NAME>
<RETURNS>void</RETURNS>
RenderOpBuilder         *builder, const GskRoundedRect    *clip
</FUNCTION>
<FUNCTION>
<NAME>ops_pop_clip</NAME>
<RETURNS>void</RETURNS>
RenderOpBuilder         *builder
</FUNCTION>
<FUNCTION>
<NAME>ops_has_clip</NAME>
<RETURNS>gboolean</RETURNS>
RenderOpBuilder         *builder
</FUNCTION>
<FUNCTION>
<NAME>ops_transform_bounds_modelview</NAME>
<RETURNS>void</RETURNS>
const RenderOpBuilder *builder, const graphene_rect_t *src, graphene_rect_t       *dst
</FUNCTION>
<FUNCTION>
<NAME>ops_set_projection</NAME>
<RETURNS>graphene_matrix_t</RETURNS>
RenderOpBuilder         *builder, const graphene_matrix_t *projection
</FUNCTION>
<FUNCTION>
<NAME>ops_set_viewport</NAME>
<RETURNS>graphene_rect_t</RETURNS>
RenderOpBuilder         *builder, const graphene_rect_t   *viewport
</FUNCTION>
<FUNCTION>
<NAME>ops_set_texture</NAME>
<RETURNS>void</RETURNS>
RenderOpBuilder         *builder, int                      texture_id
</FUNCTION>
<FUNCTION>
<NAME>ops_set_render_target</NAME>
<RETURNS>int</RETURNS>
RenderOpBuilder         *builder, int                      render_target_id
</FUNCTION>
<FUNCTION>
<NAME>ops_set_opacity</NAME>
<RETURNS>float</RETURNS>
RenderOpBuilder         *builder, float                    opacity
</FUNCTION>
<FUNCTION>
<NAME>ops_set_color</NAME>
<RETURNS>void</RETURNS>
RenderOpBuilder         *builder, const GdkRGBA           *color
</FUNCTION>
<FUNCTION>
<NAME>ops_set_color_matrix</NAME>
<RETURNS>void</RETURNS>
RenderOpBuilder         *builder, const graphene_matrix_t *matrix, const graphene_vec4_t   *offset
</FUNCTION>
<FUNCTION>
<NAME>ops_set_border</NAME>
<RETURNS>void</RETURNS>
RenderOpBuilder         *builder, const GskRoundedRect    *outline
</FUNCTION>
<FUNCTION>
<NAME>ops_set_border_width</NAME>
<RETURNS>void</RETURNS>
RenderOpBuilder         *builder, const float             *widths
</FUNCTION>
<FUNCTION>
<NAME>ops_set_border_color</NAME>
<RETURNS>void</RETURNS>
RenderOpBuilder         *builder, const GdkRGBA           *color
</FUNCTION>
<FUNCTION>
<NAME>ops_set_inset_shadow</NAME>
<RETURNS>void</RETURNS>
RenderOpBuilder         *self, const GskRoundedRect     outline, float                    spread, const GdkRGBA           *color, float                    dx, float                    dy
</FUNCTION>
<FUNCTION>
<NAME>ops_set_unblurred_outset_shadow</NAME>
<RETURNS>void</RETURNS>
RenderOpBuilder         *self, const GskRoundedRect     outline, float                    spread, const GdkRGBA           *color, float                    dx, float                    dy
</FUNCTION>
<FUNCTION>
<NAME>ops_set_linear_gradient</NAME>
<RETURNS>void</RETURNS>
RenderOpBuilder     *self, guint                n_color_stops, const GskColorStop  *color_stops, float                start_x, float                start_y, float                end_x, float                end_y
</FUNCTION>
<FUNCTION>
<NAME>ops_draw</NAME>
<RETURNS>GskQuadVertex *</RETURNS>
RenderOpBuilder        *builder, const GskQuadVertex     vertex_data[GL_N_VERTICES]
</FUNCTION>
<FUNCTION>
<NAME>ops_offset</NAME>
<RETURNS>void</RETURNS>
RenderOpBuilder        *builder, float                   x, float                   y
</FUNCTION>
<FUNCTION>
<NAME>ops_begin</NAME>
<RETURNS>gpointer</RETURNS>
RenderOpBuilder        *builder, OpKind                  kind
</FUNCTION>
<FUNCTION>
<NAME>ops_get_buffer</NAME>
<RETURNS>OpBuffer *</RETURNS>
RenderOpBuilder        *builder
</FUNCTION>
<FUNCTION>
<NAME>gsk_gl_shader_builder_init</NAME>
<RETURNS>void</RETURNS>
GskGLShaderBuilder  *self, const char          *common_preamble_resource_path, const char          *vs_preamble_resource_path, const char          *fs_preamble_resource_path
</FUNCTION>
<FUNCTION>
<NAME>gsk_gl_shader_builder_finish</NAME>
<RETURNS>void</RETURNS>
GskGLShaderBuilder  *self
</FUNCTION>
<FUNCTION>
<NAME>gsk_gl_shader_builder_set_glsl_version</NAME>
<RETURNS>void</RETURNS>
GskGLShaderBuilder  *self, int                  version
</FUNCTION>
<FUNCTION>
<NAME>gsk_gl_shader_builder_create_program</NAME>
<RETURNS>int</RETURNS>
GskGLShaderBuilder  *self, const char          *resource_path, GError             **error
</FUNCTION>
<FUNCTION>
<NAME>gsk_gl_shadow_cache_init</NAME>
<RETURNS>void</RETURNS>
GskGLShadowCache     *self
</FUNCTION>
<FUNCTION>
<NAME>gsk_gl_shadow_cache_free</NAME>
<RETURNS>void</RETURNS>
GskGLShadowCache     *self, GskGLDriver          *gl_driver
</FUNCTION>
<FUNCTION>
<NAME>gsk_gl_shadow_cache_begin_frame</NAME>
<RETURNS>void</RETURNS>
GskGLShadowCache     *self, GskGLDriver          *gl_driver
</FUNCTION>
<FUNCTION>
<NAME>gsk_gl_shadow_cache_get_texture_id</NAME>
<RETURNS>int</RETURNS>
GskGLShadowCache     *self, GskGLDriver          *gl_driver, const GskRoundedRect *shadow_rect, float                 blur_radius
</FUNCTION>
<FUNCTION>
<NAME>gsk_gl_shadow_cache_commit</NAME>
<RETURNS>void</RETURNS>
GskGLShadowCache     *self, const GskRoundedRect *shadow_rect, float                 blur_radius, int                   texture_id
</FUNCTION>
<STRUCT>
<NAME>GskGLTextureAtlas</NAME>
struct _GskGLTextureAtlas
{
  struct stbrp_context context;
  struct stbrp_node *nodes;

  int width;
  int height;

  guint texture_id;

  int unused_pixels; /* Pixels of rects that have been used at some point,
                        But are now unused. */

  void *user_data;
};
</STRUCT>
<STRUCT>
<NAME>GskGLTextureAtlases</NAME>
struct _GskGLTextureAtlases
{
  int ref_count;

  GPtrArray *atlases;
};
</STRUCT>
<FUNCTION>
<NAME>gsk_gl_texture_atlases_new</NAME>
<RETURNS>GskGLTextureAtlases *</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gsk_gl_texture_atlases_ref</NAME>
<RETURNS>GskGLTextureAtlases *</RETURNS>
GskGLTextureAtlases *atlases
</FUNCTION>
<FUNCTION>
<NAME>gsk_gl_texture_atlases_unref</NAME>
<RETURNS>void</RETURNS>
GskGLTextureAtlases *atlases
</FUNCTION>
<FUNCTION>
<NAME>gsk_gl_texture_atlases_begin_frame</NAME>
<RETURNS>void</RETURNS>
GskGLTextureAtlases *atlases, GPtrArray           *removed
</FUNCTION>
<FUNCTION>
<NAME>gsk_gl_texture_atlases_pack</NAME>
<RETURNS>gboolean</RETURNS>
GskGLTextureAtlases *atlases, int                  width, int                  height, GskGLTextureAtlas  **atlas_out, int                 *out_x, int                 *out_y
</FUNCTION>
<FUNCTION>
<NAME>gsk_gl_texture_atlas_init</NAME>
<RETURNS>void</RETURNS>
GskGLTextureAtlas       *self, int                      width, int                      height
</FUNCTION>
<FUNCTION>
<NAME>gsk_gl_texture_atlas_free</NAME>
<RETURNS>void</RETURNS>
GskGLTextureAtlas       *self
</FUNCTION>
<FUNCTION>
<NAME>gsk_gl_texture_atlas_realize</NAME>
<RETURNS>void</RETURNS>
GskGLTextureAtlas       *self
</FUNCTION>
<FUNCTION>
<NAME>gsk_gl_texture_atlas_mark_unused</NAME>
<RETURNS>void</RETURNS>
GskGLTextureAtlas       *self, int                      width, int                      height
</FUNCTION>
<FUNCTION>
<NAME>gsk_gl_texture_atlas_mark_used</NAME>
<RETURNS>void</RETURNS>
GskGLTextureAtlas       *self, int                      width, int                      height
</FUNCTION>
<FUNCTION>
<NAME>gsk_gl_texture_atlas_pack</NAME>
<RETURNS>gboolean</RETURNS>
GskGLTextureAtlas       *self, int                      width, int                      height, int                     *out_x, int                     *out_y
</FUNCTION>
<FUNCTION>
<NAME>gsk_gl_texture_atlas_get_unused_ratio</NAME>
<RETURNS>double</RETURNS>
const GskGLTextureAtlas *self
</FUNCTION>
<STRUCT>
<NAME>GskGLTextureAtlas</NAME>
</STRUCT>
<STRUCT>
<NAME>GskGLTextureAtlases</NAME>
</STRUCT>
<ENUM>
<NAME>OpKind</NAME>
typedef enum
{
  OP_NONE                              =  0,
  OP_CHANGE_OPACITY                    =  1,
  OP_CHANGE_COLOR                      =  2,
  OP_CHANGE_PROJECTION                 =  3,
  OP_CHANGE_MODELVIEW                  =  4,
  OP_CHANGE_PROGRAM                    =  5,
  OP_CHANGE_RENDER_TARGET              =  6,
  OP_CHANGE_CLIP                       =  7,
  OP_CHANGE_VIEWPORT                   =  8,
  OP_CHANGE_SOURCE_TEXTURE             =  9,
  OP_CHANGE_REPEAT                     = 10,
  OP_CHANGE_LINEAR_GRADIENT            = 11,
  OP_CHANGE_COLOR_MATRIX               = 12,
  OP_CHANGE_BLUR                       = 13,
  OP_CHANGE_INSET_SHADOW               = 14,
  OP_CHANGE_OUTSET_SHADOW              = 15,
  OP_CHANGE_BORDER                     = 16,
  OP_CHANGE_BORDER_COLOR               = 17,
  OP_CHANGE_BORDER_WIDTH               = 18,
  OP_CHANGE_CROSS_FADE                 = 19,
  OP_CHANGE_UNBLURRED_OUTSET_SHADOW    = 20,
  OP_CLEAR                             = 21,
  OP_DRAW                              = 22,
  OP_DUMP_FRAMEBUFFER                  = 23,
  OP_PUSH_DEBUG_GROUP                  = 24,
  OP_POP_DEBUG_GROUP                   = 25,
  OP_CHANGE_BLEND                      = 26,
  OP_LAST
} OpKind;
</ENUM>
<STRUCT>
<NAME>OpShadow</NAME>
typedef struct { int value; guint send: 1; }    IntUniformValue;
typedef struct { float value; guint send: 1; }    FloatUniformValue;
typedef struct { float value[2]; guint send: 1; } Float2UniformValue;
typedef struct { GskRoundedRect value; guint send: 1; guint send_corners: 1; } RRUniformValue;
typedef struct { const GdkRGBA *value; guint send: 1; } RGBAUniformValue;
typedef struct { const graphene_vec4_t *value; guint send: 1; } Vec4UniformValue;
typedef struct { const GskColorStop *value; guint send: 1; } ColorStopUniformValue;

/* OpNode are allocated within OpBuffer.pos, but we keep
 * a secondary index into the locations of that buffer
 * from OpBuffer.index. This allows peeking at the kind
 * and quickly replacing existing entries when necessary.
 */
typedef struct
{
  RRUniformValue outline;
  FloatUniformValue spread;
  Float2UniformValue offset;
  RGBAUniformValue color;
} OpShadow;
</STRUCT>
<FUNCTION>
<NAME>op_buffer_init</NAME>
<RETURNS>void</RETURNS>
OpBuffer *buffer
</FUNCTION>
<FUNCTION>
<NAME>op_buffer_destroy</NAME>
<RETURNS>void</RETURNS>
OpBuffer *buffer
</FUNCTION>
<FUNCTION>
<NAME>op_buffer_clear</NAME>
<RETURNS>void</RETURNS>
OpBuffer *buffer
</FUNCTION>
<FUNCTION>
<NAME>op_buffer_add</NAME>
<RETURNS>gpointer</RETURNS>
OpBuffer *buffer, OpKind    kind
</FUNCTION>
<FUNCTION>
<NAME>op_buffer_iter_init</NAME>
<RETURNS>void</RETURNS>
OpBufferIter *iter, OpBuffer     *buffer
</FUNCTION>
<FUNCTION>
<NAME>op_buffer_iter_next</NAME>
<RETURNS>gpointer</RETURNS>
OpBufferIter *iter, OpKind       *kind
</FUNCTION>
<FUNCTION>
<NAME>op_buffer_pop_tail</NAME>
<RETURNS>void</RETURNS>
OpBuffer *buffer
</FUNCTION>
<FUNCTION>
<NAME>op_buffer_peek_tail</NAME>
<RETURNS>gpointer</RETURNS>
OpBuffer *buffer, OpKind   *kind
</FUNCTION>
<FUNCTION>
<NAME>op_buffer_peek_tail_checked</NAME>
<RETURNS>gpointer</RETURNS>
OpBuffer *buffer, OpKind    kind
</FUNCTION>
<FUNCTION>
<NAME>op_buffer_n_ops</NAME>
<RETURNS>guint</RETURNS>
OpBuffer *buffer
</FUNCTION>
<STRUCT>
<NAME>Program</NAME>
</STRUCT>
<MACRO>
<NAME>STB_RECT_PACK_VERSION</NAME>
#define STB_RECT_PACK_VERSION  1
</MACRO>
<MACRO>
<NAME>STBRP_DEF</NAME>
#define STBRP_DEF static
</MACRO>
<TYPEDEF>
<NAME>stbrp_context</NAME>
typedef struct stbrp_context stbrp_context;
</TYPEDEF>
<TYPEDEF>
<NAME>stbrp_node</NAME>
typedef struct stbrp_node    stbrp_node;
</TYPEDEF>
<TYPEDEF>
<NAME>stbrp_rect</NAME>
typedef struct stbrp_rect    stbrp_rect;
</TYPEDEF>
<TYPEDEF>
<NAME>stbrp_coord</NAME>
typedef int            stbrp_coord;
</TYPEDEF>
<MACRO>
<NAME>GSK_TYPE_VULKAN_BLEND_MODE_PIPELINE</NAME>
#define GSK_TYPE_VULKAN_BLEND_MODE_PIPELINE (gsk_vulkan_blend_mode_pipeline_get_type ())
</MACRO>
<FUNCTION>
<NAME>gsk_vulkan_blend_mode_pipeline_new</NAME>
<RETURNS>GskVulkanPipeline *</RETURNS>
GdkVulkanContext           *context, VkPipelineLayout            layout, const char                 *shader_name, VkRenderPass                render_pass
</FUNCTION>
<FUNCTION>
<NAME>gsk_vulkan_blend_mode_pipeline_count_vertex_data</NAME>
<RETURNS>gsize</RETURNS>
GskVulkanBlendModePipeline *pipeline
</FUNCTION>
<FUNCTION>
<NAME>gsk_vulkan_blend_mode_pipeline_collect_vertex_data</NAME>
<RETURNS>void</RETURNS>
GskVulkanBlendModePipeline *pipeline, guchar                     *data, const graphene_rect_t      *bounds, const graphene_rect_t      *start_bounds, const graphene_rect_t      *end_bounds, GskBlendMode                blend_mode
</FUNCTION>
<FUNCTION>
<NAME>gsk_vulkan_blend_mode_pipeline_draw</NAME>
<RETURNS>gsize</RETURNS>
GskVulkanBlendModePipeline *pipeline, VkCommandBuffer             command_buffer, gsize                       offset, gsize                       n_commands
</FUNCTION>
<STRUCT>
<NAME>GskVulkanBlendModePipeline</NAME>
</STRUCT>
<STRUCT>
<NAME>GskVulkanBlendModePipelineLayout</NAME>
</STRUCT>
<MACRO>
<NAME>GSK_TYPE_VULKAN_BLUR_PIPELINE</NAME>
#define GSK_TYPE_VULKAN_BLUR_PIPELINE (gsk_vulkan_blur_pipeline_get_type ())
</MACRO>
<FUNCTION>
<NAME>gsk_vulkan_blur_pipeline_new</NAME>
<RETURNS>GskVulkanPipeline *</RETURNS>
GdkVulkanContext        *context, VkPipelineLayout         layout, const char              *shader_name, VkRenderPass             render_pass
</FUNCTION>
<FUNCTION>
<NAME>gsk_vulkan_blur_pipeline_count_vertex_data</NAME>
<RETURNS>gsize</RETURNS>
GskVulkanBlurPipeline   *pipeline
</FUNCTION>
<FUNCTION>
<NAME>gsk_vulkan_blur_pipeline_collect_vertex_data</NAME>
<RETURNS>void</RETURNS>
GskVulkanBlurPipeline   *pipeline, guchar                  *data, const graphene_rect_t   *rect, const graphene_rect_t   *tex_rect, double                   radius
</FUNCTION>
<FUNCTION>
<NAME>gsk_vulkan_blur_pipeline_draw</NAME>
<RETURNS>gsize</RETURNS>
GskVulkanBlurPipeline   *pipeline, VkCommandBuffer          command_buffer, gsize                    offset, gsize                    n_commands
</FUNCTION>
<STRUCT>
<NAME>GskVulkanBlurPipeline</NAME>
</STRUCT>
<STRUCT>
<NAME>GskVulkanBlurPipelineLayout</NAME>
</STRUCT>
<MACRO>
<NAME>GSK_TYPE_VULKAN_BORDER_PIPELINE</NAME>
#define GSK_TYPE_VULKAN_BORDER_PIPELINE (gsk_vulkan_border_pipeline_get_type ())
</MACRO>
<FUNCTION>
<NAME>gsk_vulkan_border_pipeline_new</NAME>
<RETURNS>GskVulkanPipeline *</RETURNS>
GdkVulkanContext               *context, VkPipelineLayout                layout, const char                     *shader_name, VkRenderPass                    render_pass
</FUNCTION>
<FUNCTION>
<NAME>gsk_vulkan_border_pipeline_count_vertex_data</NAME>
<RETURNS>gsize</RETURNS>
GskVulkanBorderPipeline        *pipeline
</FUNCTION>
<FUNCTION>
<NAME>gsk_vulkan_border_pipeline_collect_vertex_data</NAME>
<RETURNS>void</RETURNS>
GskVulkanBorderPipeline        *pipeline, guchar                         *data, const GskRoundedRect           *rect, const float                     widths[4], const GdkRGBA                   colors[4]
</FUNCTION>
<FUNCTION>
<NAME>gsk_vulkan_border_pipeline_draw</NAME>
<RETURNS>gsize</RETURNS>
GskVulkanBorderPipeline        *pipeline, VkCommandBuffer                 command_buffer, gsize                           offset, gsize                           n_commands
</FUNCTION>
<STRUCT>
<NAME>GskVulkanBorderPipeline</NAME>
</STRUCT>
<STRUCT>
<NAME>GskVulkanBorderPipelineLayout</NAME>
</STRUCT>
<MACRO>
<NAME>GSK_TYPE_VULKAN_BOX_SHADOW_PIPELINE</NAME>
#define GSK_TYPE_VULKAN_BOX_SHADOW_PIPELINE (gsk_vulkan_box_shadow_pipeline_get_type ())
</MACRO>
<FUNCTION>
<NAME>gsk_vulkan_box_shadow_pipeline_new</NAME>
<RETURNS>GskVulkanPipeline *</RETURNS>
GdkVulkanContext               *context, VkPipelineLayout                layout, const char                     *shader_name, VkRenderPass                    render_pass
</FUNCTION>
<FUNCTION>
<NAME>gsk_vulkan_box_shadow_pipeline_count_vertex_data</NAME>
<RETURNS>gsize</RETURNS>
GskVulkanBoxShadowPipeline    *pipeline
</FUNCTION>
<FUNCTION>
<NAME>gsk_vulkan_box_shadow_pipeline_collect_vertex_data</NAME>
<RETURNS>void</RETURNS>
GskVulkanBoxShadowPipeline  *pipeline, guchar                         *data, const GskRoundedRect           *outline, const GdkRGBA                  *color, float                           dx, float                           dy, float                           spread, float                           blur_radius
</FUNCTION>
<FUNCTION>
<NAME>gsk_vulkan_box_shadow_pipeline_draw</NAME>
<RETURNS>gsize</RETURNS>
GskVulkanBoxShadowPipeline     *pipeline, VkCommandBuffer                 command_buffer, gsize                           offset, gsize                           n_commands
</FUNCTION>
<STRUCT>
<NAME>GskVulkanBoxShadowPipeline</NAME>
</STRUCT>
<STRUCT>
<NAME>GskVulkanBoxShadowPipelineLayout</NAME>
</STRUCT>
<FUNCTION>
<NAME>gsk_vulkan_buffer_new</NAME>
<RETURNS>GskVulkanBuffer *</RETURNS>
GdkVulkanContext       *context, gsize                   size
</FUNCTION>
<FUNCTION>
<NAME>gsk_vulkan_buffer_new_staging</NAME>
<RETURNS>GskVulkanBuffer *</RETURNS>
GdkVulkanContext       *context, gsize                   size
</FUNCTION>
<FUNCTION>
<NAME>gsk_vulkan_buffer_new_download</NAME>
<RETURNS>GskVulkanBuffer *</RETURNS>
GdkVulkanContext       *context, gsize                   size
</FUNCTION>
<FUNCTION>
<NAME>gsk_vulkan_buffer_free</NAME>
<RETURNS>void</RETURNS>
GskVulkanBuffer        *buffer
</FUNCTION>
<FUNCTION>
<NAME>gsk_vulkan_buffer_get_buffer</NAME>
<RETURNS>VkBuffer</RETURNS>
GskVulkanBuffer        *self
</FUNCTION>
<FUNCTION>
<NAME>gsk_vulkan_buffer_map</NAME>
<RETURNS>guchar *</RETURNS>
GskVulkanBuffer        *self
</FUNCTION>
<FUNCTION>
<NAME>gsk_vulkan_buffer_unmap</NAME>
<RETURNS>void</RETURNS>
GskVulkanBuffer        *self
</FUNCTION>
<STRUCT>
<NAME>GskVulkanBuffer</NAME>
</STRUCT>
<ENUM>
<NAME>GskVulkanClipComplexity</NAME>
typedef enum {
  /* The whole area is clipped, no drawing is necessary.
   * This can't be handled by return values because for return
   * values we return if clips could even be computed.
   */
  GSK_VULKAN_CLIP_ALL_CLIPPED,
  /* No clipping is necessary, but the clip rect is set
   * to the actual bounds of the underlying framebuffer
   */
  GSK_VULKAN_CLIP_NONE,
  /* The clip is a rectangular area */
  GSK_VULKAN_CLIP_RECT,
  /* The clip is a rounded rectangle, and for every corner
   * corner.width == corner.height is true
   */
  GSK_VULKAN_CLIP_ROUNDED_CIRCULAR,
  /* The clip is a rounded rectangle */
  GSK_VULKAN_CLIP_ROUNDED
} GskVulkanClipComplexity;
</ENUM>
<STRUCT>
<NAME>GskVulkanClip</NAME>
struct _GskVulkanClip
{
  GskVulkanClipComplexity type;
  GskRoundedRect          rect;
};
</STRUCT>
<FUNCTION>
<NAME>gsk_vulkan_clip_init_empty</NAME>
<RETURNS>void</RETURNS>
GskVulkanClip          *clip, const graphene_rect_t  *rect
</FUNCTION>
<FUNCTION>
<NAME>gsk_vulkan_clip_intersect_rect</NAME>
<RETURNS>gboolean</RETURNS>
GskVulkanClip          *dest, const GskVulkanClip    *src, const graphene_rect_t  *rect
</FUNCTION>
<FUNCTION>
<NAME>gsk_vulkan_clip_intersect_rounded_rect</NAME>
<RETURNS>gboolean</RETURNS>
GskVulkanClip          *dest, const GskVulkanClip    *src, const GskRoundedRect   *rounded
</FUNCTION>
<FUNCTION>
<NAME>gsk_vulkan_clip_transform</NAME>
<RETURNS>gboolean</RETURNS>
GskVulkanClip          *dest, const GskVulkanClip    *src, const graphene_matrix_t*transform, const graphene_rect_t  *viewport
</FUNCTION>
<FUNCTION>
<NAME>gsk_vulkan_clip_contains_rect</NAME>
<RETURNS>gboolean</RETURNS>
const GskVulkanClip    *self, const graphene_rect_t  *rect
</FUNCTION>
<MACRO>
<NAME>GSK_TYPE_VULKAN_COLOR_PIPELINE</NAME>
#define GSK_TYPE_VULKAN_COLOR_PIPELINE (gsk_vulkan_color_pipeline_get_type ())
</MACRO>
<FUNCTION>
<NAME>gsk_vulkan_color_pipeline_new</NAME>
<RETURNS>GskVulkanPipeline *</RETURNS>
GdkVulkanContext               *context, VkPipelineLayout                layout, const char                     *shader_name, VkRenderPass                    render_pass
</FUNCTION>
<FUNCTION>
<NAME>gsk_vulkan_color_pipeline_count_vertex_data</NAME>
<RETURNS>gsize</RETURNS>
GskVulkanColorPipeline         *pipeline
</FUNCTION>
<FUNCTION>
<NAME>gsk_vulkan_color_pipeline_collect_vertex_data</NAME>
<RETURNS>void</RETURNS>
GskVulkanColorPipeline         *pipeline, guchar                         *data, const graphene_rect_t          *rect, const GdkRGBA                  *color
</FUNCTION>
<FUNCTION>
<NAME>gsk_vulkan_color_pipeline_draw</NAME>
<RETURNS>gsize</RETURNS>
GskVulkanColorPipeline         *pipeline, VkCommandBuffer                 command_buffer, gsize                           offset, gsize                           n_commands
</FUNCTION>
<STRUCT>
<NAME>GskVulkanColorPipeline</NAME>
</STRUCT>
<STRUCT>
<NAME>GskVulkanColorPipelineLayout</NAME>
</STRUCT>
<MACRO>
<NAME>GSK_TYPE_VULKAN_COLOR_TEXT_PIPELINE</NAME>
#define GSK_TYPE_VULKAN_COLOR_TEXT_PIPELINE (gsk_vulkan_color_text_pipeline_get_type ())
</MACRO>
<FUNCTION>
<NAME>gsk_vulkan_color_text_pipeline_new</NAME>
<RETURNS>GskVulkanPipeline *</RETURNS>
GdkVulkanContext               *context, VkPipelineLayout                layout, const char                     *shader_name, VkRenderPass                    render_pass
</FUNCTION>
<FUNCTION>
<NAME>gsk_vulkan_color_text_pipeline_count_vertex_data</NAME>
<RETURNS>gsize</RETURNS>
GskVulkanColorTextPipeline     *pipeline, int                             num_instances
</FUNCTION>
<FUNCTION>
<NAME>gsk_vulkan_color_text_pipeline_collect_vertex_data</NAME>
<RETURNS>void</RETURNS>
GskVulkanColorTextPipeline     *pipeline, guchar                         *data, GskVulkanRenderer              *renderer, const graphene_rect_t          *rect, PangoFont                      *font, guint                           total_glyphs, const PangoGlyphInfo           *glyphs, const graphene_point_t         *offset, guint                           start_glyph, guint                           num_glyphs, float                           scale
</FUNCTION>
<FUNCTION>
<NAME>gsk_vulkan_color_text_pipeline_draw</NAME>
<RETURNS>gsize</RETURNS>
GskVulkanColorTextPipeline     *pipeline, VkCommandBuffer                 command_buffer, gsize                           offset, gsize                           n_commands
</FUNCTION>
<STRUCT>
<NAME>GskVulkanColorTextPipeline</NAME>
</STRUCT>
<STRUCT>
<NAME>GskVulkanColorTextPipelineLayout</NAME>
</STRUCT>
<FUNCTION>
<NAME>gsk_vulkan_command_pool_new</NAME>
<RETURNS>GskVulkanCommandPool *</RETURNS>
GdkVulkanContext       *context
</FUNCTION>
<FUNCTION>
<NAME>gsk_vulkan_command_pool_free</NAME>
<RETURNS>void</RETURNS>
GskVulkanCommandPool   *self
</FUNCTION>
<FUNCTION>
<NAME>gsk_vulkan_command_pool_reset</NAME>
<RETURNS>void</RETURNS>
GskVulkanCommandPool   *self
</FUNCTION>
<FUNCTION>
<NAME>gsk_vulkan_command_pool_get_buffer</NAME>
<RETURNS>VkCommandBuffer</RETURNS>
GskVulkanCommandPool   *self
</FUNCTION>
<FUNCTION>
<NAME>gsk_vulkan_command_pool_submit_buffer</NAME>
<RETURNS>void</RETURNS>
GskVulkanCommandPool   *self, VkCommandBuffer         buffer, gsize                   wait_semaphore_count, VkSemaphore            *wait_semaphores, gsize                   signal_semaphores_count, VkSemaphore            *signal_semaphores, VkFence                 fence
</FUNCTION>
<STRUCT>
<NAME>GskVulkanCommandPool</NAME>
</STRUCT>
<MACRO>
<NAME>GSK_TYPE_VULKAN_CROSS_FADE_PIPELINE</NAME>
#define GSK_TYPE_VULKAN_CROSS_FADE_PIPELINE (gsk_vulkan_cross_fade_pipeline_get_type ())
</MACRO>
<FUNCTION>
<NAME>gsk_vulkan_cross_fade_pipeline_new</NAME>
<RETURNS>GskVulkanPipeline *</RETURNS>
GdkVulkanContext           *context, VkPipelineLayout            layout, const char                 *shader_name, VkRenderPass                render_pass
</FUNCTION>
<FUNCTION>
<NAME>gsk_vulkan_cross_fade_pipeline_count_vertex_data</NAME>
<RETURNS>gsize</RETURNS>
GskVulkanCrossFadePipeline *pipeline
</FUNCTION>
<FUNCTION>
<NAME>gsk_vulkan_cross_fade_pipeline_collect_vertex_data</NAME>
<RETURNS>void</RETURNS>
GskVulkanCrossFadePipeline *pipeline, guchar                     *data, const graphene_rect_t      *bounds, const graphene_rect_t      *start_bounds, const graphene_rect_t      *end_bounds, double                      progress
</FUNCTION>
<FUNCTION>
<NAME>gsk_vulkan_cross_fade_pipeline_draw</NAME>
<RETURNS>gsize</RETURNS>
GskVulkanCrossFadePipeline *pipeline, VkCommandBuffer             command_buffer, gsize                       offset, gsize                       n_commands
</FUNCTION>
<STRUCT>
<NAME>GskVulkanCrossFadePipeline</NAME>
</STRUCT>
<STRUCT>
<NAME>GskVulkanCrossFadePipelineLayout</NAME>
</STRUCT>
<MACRO>
<NAME>GSK_TYPE_VULKAN_EFFECT_PIPELINE</NAME>
#define GSK_TYPE_VULKAN_EFFECT_PIPELINE (gsk_vulkan_effect_pipeline_get_type ())
</MACRO>
<FUNCTION>
<NAME>gsk_vulkan_effect_pipeline_new</NAME>
<RETURNS>GskVulkanPipeline *</RETURNS>
GdkVulkanContext               *context, VkPipelineLayout                layout, const char                     *shader_name, VkRenderPass                    render_pass
</FUNCTION>
<FUNCTION>
<NAME>gsk_vulkan_effect_pipeline_count_vertex_data</NAME>
<RETURNS>gsize</RETURNS>
GskVulkanEffectPipeline        *pipeline
</FUNCTION>
<FUNCTION>
<NAME>gsk_vulkan_effect_pipeline_collect_vertex_data</NAME>
<RETURNS>void</RETURNS>
GskVulkanEffectPipeline        *pipeline, guchar                         *data, const graphene_rect_t          *rect, const graphene_rect_t          *tex_rect, const graphene_matrix_t        *color_matrix, const graphene_vec4_t          *color_offset
</FUNCTION>
<FUNCTION>
<NAME>gsk_vulkan_effect_pipeline_draw</NAME>
<RETURNS>gsize</RETURNS>
GskVulkanEffectPipeline        *pipeline, VkCommandBuffer                 command_buffer, gsize                           offset, gsize                           n_commands
</FUNCTION>
<STRUCT>
<NAME>GskVulkanEffectPipeline</NAME>
</STRUCT>
<STRUCT>
<NAME>GskVulkanEffectPipelineLayout</NAME>
</STRUCT>
<MACRO>
<NAME>GSK_TYPE_VULKAN_GLYPH_CACHE</NAME>
#define GSK_TYPE_VULKAN_GLYPH_CACHE (gsk_vulkan_glyph_cache_get_type ())
</MACRO>
<FUNCTION>
<NAME>gsk_vulkan_glyph_cache_new</NAME>
<RETURNS>GskVulkanGlyphCache *</RETURNS>
GskRenderer         *renderer, GdkVulkanContext    *vulkan
</FUNCTION>
<FUNCTION>
<NAME>gsk_vulkan_glyph_cache_get_glyph_image</NAME>
<RETURNS>GskVulkanImage *</RETURNS>
GskVulkanGlyphCache *cache, GskVulkanUploader   *uploader, guint                index
</FUNCTION>
<FUNCTION>
<NAME>gsk_vulkan_glyph_cache_lookup</NAME>
<RETURNS>GskVulkanCachedGlyph *</RETURNS>
GskVulkanGlyphCache *cache, gboolean             create, PangoFont           *font, PangoGlyph           glyph, int                  x, int                  y, float                scale
</FUNCTION>
<FUNCTION>
<NAME>gsk_vulkan_glyph_cache_begin_frame</NAME>
<RETURNS>void</RETURNS>
GskVulkanGlyphCache *cache
</FUNCTION>
<STRUCT>
<NAME>GskVulkanGlyphCache</NAME>
</STRUCT>
<MACRO>
<NAME>GSK_TYPE_VULKAN_IMAGE</NAME>
#define GSK_TYPE_VULKAN_IMAGE (gsk_vulkan_image_get_type ())
</MACRO>
<FUNCTION>
<NAME>gsk_vulkan_uploader_new</NAME>
<RETURNS>GskVulkanUploader *</RETURNS>
GdkVulkanContext       *context, GskVulkanCommandPool   *command_pool
</FUNCTION>
<FUNCTION>
<NAME>gsk_vulkan_uploader_free</NAME>
<RETURNS>void</RETURNS>
GskVulkanUploader      *self
</FUNCTION>
<FUNCTION>
<NAME>gsk_vulkan_uploader_reset</NAME>
<RETURNS>void</RETURNS>
GskVulkanUploader      *self
</FUNCTION>
<FUNCTION>
<NAME>gsk_vulkan_uploader_upload</NAME>
<RETURNS>void</RETURNS>
GskVulkanUploader      *self
</FUNCTION>
<FUNCTION>
<NAME>gsk_vulkan_image_new_for_swapchain</NAME>
<RETURNS>GskVulkanImage *</RETURNS>
GdkVulkanContext       *context, VkImage                 image, VkFormat                format, gsize                   width, gsize                   height
</FUNCTION>
<FUNCTION>
<NAME>gsk_vulkan_image_new_from_data</NAME>
<RETURNS>GskVulkanImage *</RETURNS>
GskVulkanUploader      *uploader, guchar                 *data, gsize                   width, gsize                   height, gsize                   stride
</FUNCTION>
<STRUCT>
<NAME>GskImageRegion</NAME>
typedef struct {
  guchar *data;
  gsize width;
  gsize height;
  gsize stride;
  gsize x;
  gsize y;
} GskImageRegion;
</STRUCT>
<FUNCTION>
<NAME>gsk_vulkan_image_upload_regions</NAME>
<RETURNS>void</RETURNS>
GskVulkanImage         *image, GskVulkanUploader      *uploader, guint                   num_regions, GskImageRegion         *regions
</FUNCTION>
<FUNCTION>
<NAME>gsk_vulkan_image_new_for_framebuffer</NAME>
<RETURNS>GskVulkanImage *</RETURNS>
GdkVulkanContext       *context, gsize                   width, gsize                   height
</FUNCTION>
<FUNCTION>
<NAME>gsk_vulkan_image_new_for_atlas</NAME>
<RETURNS>GskVulkanImage *</RETURNS>
GdkVulkanContext       *context, gsize                   width, gsize                   height
</FUNCTION>
<FUNCTION>
<NAME>gsk_vulkan_image_new_for_texture</NAME>
<RETURNS>GskVulkanImage *</RETURNS>
GdkVulkanContext       *context, gsize                   width, gsize                   height
</FUNCTION>
<FUNCTION>
<NAME>gsk_vulkan_image_download</NAME>
<RETURNS>GdkTexture *</RETURNS>
GskVulkanImage         *self, GskVulkanUploader      *uploader
</FUNCTION>
<FUNCTION>
<NAME>gsk_vulkan_image_get_width</NAME>
<RETURNS>gsize</RETURNS>
GskVulkanImage         *self
</FUNCTION>
<FUNCTION>
<NAME>gsk_vulkan_image_get_height</NAME>
<RETURNS>gsize</RETURNS>
GskVulkanImage         *self
</FUNCTION>
<FUNCTION>
<NAME>gsk_vulkan_image_get_image</NAME>
<RETURNS>VkImage</RETURNS>
GskVulkanImage         *self
</FUNCTION>
<FUNCTION>
<NAME>gsk_vulkan_image_get_image_view</NAME>
<RETURNS>VkImageView</RETURNS>
GskVulkanImage         *self
</FUNCTION>
<STRUCT>
<NAME>GskVulkanImage</NAME>
</STRUCT>
<STRUCT>
<NAME>GskVulkanUploader</NAME>
</STRUCT>
<MACRO>
<NAME>GSK_VULKAN_LINEAR_GRADIENT_PIPELINE_MAX_COLOR_STOPS</NAME>
#define GSK_VULKAN_LINEAR_GRADIENT_PIPELINE_MAX_COLOR_STOPS 8
</MACRO>
<MACRO>
<NAME>GSK_TYPE_VULKAN_LINEAR_GRADIENT_PIPELINE</NAME>
#define GSK_TYPE_VULKAN_LINEAR_GRADIENT_PIPELINE (gsk_vulkan_linear_gradient_pipeline_get_type ())
</MACRO>
<FUNCTION>
<NAME>gsk_vulkan_linear_gradient_pipeline_new</NAME>
<RETURNS>GskVulkanPipeline *</RETURNS>
GdkVulkanContext               *context, VkPipelineLayout                layout, const char                     *shader_name, VkRenderPass                    render_pass
</FUNCTION>
<FUNCTION>
<NAME>gsk_vulkan_linear_gradient_pipeline_count_vertex_data</NAME>
<RETURNS>gsize</RETURNS>
GskVulkanLinearGradientPipeline*pipeline
</FUNCTION>
<FUNCTION>
<NAME>gsk_vulkan_linear_gradient_pipeline_collect_vertex_data</NAME>
<RETURNS>void</RETURNS>
GskVulkanLinearGradientPipeline*pipeline, guchar                         *data, const graphene_rect_t          *rect, const graphene_point_t         *start, const graphene_point_t         *end, gboolean                        repeating, gsize                           n_stops, const GskColorStop             *stops
</FUNCTION>
<FUNCTION>
<NAME>gsk_vulkan_linear_gradient_pipeline_draw</NAME>
<RETURNS>gsize</RETURNS>
GskVulkanLinearGradientPipeline*pipeline, VkCommandBuffer                 command_buffer, gsize                           offset, gsize                           n_commands
</FUNCTION>
<STRUCT>
<NAME>GskVulkanLinearGradientPipeline</NAME>
</STRUCT>
<STRUCT>
<NAME>GskVulkanLinearGradientPipelineLayout</NAME>
</STRUCT>
<FUNCTION>
<NAME>gsk_vulkan_memory_new</NAME>
<RETURNS>GskVulkanMemory *</RETURNS>
GdkVulkanContext       *context, uint32_t                allowed_types, VkMemoryPropertyFlags   properties, gsize                   size
</FUNCTION>
<FUNCTION>
<NAME>gsk_vulkan_memory_free</NAME>
<RETURNS>void</RETURNS>
GskVulkanMemory        *memory
</FUNCTION>
<FUNCTION>
<NAME>gsk_vulkan_memory_get_device_memory</NAME>
<RETURNS>VkDeviceMemory</RETURNS>
GskVulkanMemory        *self
</FUNCTION>
<FUNCTION>
<NAME>gsk_vulkan_memory_map</NAME>
<RETURNS>guchar *</RETURNS>
GskVulkanMemory        *self
</FUNCTION>
<FUNCTION>
<NAME>gsk_vulkan_memory_unmap</NAME>
<RETURNS>void</RETURNS>
GskVulkanMemory        *self
</FUNCTION>
<STRUCT>
<NAME>GskVulkanMemory</NAME>
</STRUCT>
<MACRO>
<NAME>GSK_TYPE_VULKAN_PIPELINE</NAME>
#define GSK_TYPE_VULKAN_PIPELINE (gsk_vulkan_pipeline_get_type ())
</MACRO>
<STRUCT>
<NAME>GskVulkanPipelineClass</NAME>
struct _GskVulkanPipelineClass
{
  GObjectClass parent_class;

  const VkPipelineVertexInputStateCreateInfo *
                                (* get_input_state_create_info)         (GskVulkanPipeline              *self);
};
</STRUCT>
<FUNCTION>
<NAME>gsk_vulkan_handle_result</NAME>
<RETURNS>VkResult</RETURNS>
VkResult    res, const char *called_function
</FUNCTION>
<MACRO>
<NAME>GSK_VK_CHECK</NAME>
#define GSK_VK_CHECK(func, ...) gsk_vulkan_handle_result (func (__VA_ARGS__), G_STRINGIFY (func))
</MACRO>
<FUNCTION>
<NAME>gsk_vulkan_pipeline_new</NAME>
<RETURNS>GskVulkanPipeline *</RETURNS>
GType                           pipeline_type, GdkVulkanContext               *context, VkPipelineLayout                layout, const char                     *shader_name, VkRenderPass                    render_pass
</FUNCTION>
<FUNCTION>
<NAME>gsk_vulkan_pipeline_new_full</NAME>
<RETURNS>GskVulkanPipeline *</RETURNS>
GType                           pipeline_type, GdkVulkanContext               *context, VkPipelineLayout                layout, const char                     *shader_name, VkRenderPass                    render_pass, VkBlendFactor                   srcBlendFactor, VkBlendFactor                   dstBlendFactor
</FUNCTION>
<FUNCTION>
<NAME>gsk_vulkan_pipeline_get_pipeline</NAME>
<RETURNS>VkPipeline</RETURNS>
GskVulkanPipeline              *self
</FUNCTION>
<FUNCTION>
<NAME>gsk_vulkan_pipeline_get_pipeline_layout</NAME>
<RETURNS>VkPipelineLayout</RETURNS>
GskVulkanPipeline              *self
</FUNCTION>
<STRUCT>
<NAME>GskVulkanPipeline</NAME>
</STRUCT>
<STRUCT>
<NAME>GskVulkanPushConstants</NAME>
struct _GskVulkanPushConstants
{
  graphene_matrix_t mvp;
  GskVulkanClip clip;
};
</STRUCT>
<FUNCTION>
<NAME>gsk_vulkan_push_constants_get_ranges</NAME>
<RETURNS>const VkPushConstantRange *</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gsk_vulkan_push_constants_get_range_count</NAME>
<RETURNS>uint32_t</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gsk_vulkan_push_constants_init</NAME>
<RETURNS>void</RETURNS>
GskVulkanPushConstants         *constants, const graphene_matrix_t        *mvp, const graphene_rect_t          *viewport
</FUNCTION>
<FUNCTION>
<NAME>gsk_vulkan_push_constants_init_copy</NAME>
<RETURNS>void</RETURNS>
GskVulkanPushConstants         *self, const GskVulkanPushConstants   *src
</FUNCTION>
<FUNCTION>
<NAME>gsk_vulkan_push_constants_transform</NAME>
<RETURNS>gboolean</RETURNS>
GskVulkanPushConstants         *self, const GskVulkanPushConstants   *src, const graphene_matrix_t        *transform, const graphene_rect_t          *viewport
</FUNCTION>
<FUNCTION>
<NAME>gsk_vulkan_push_constants_intersect_rect</NAME>
<RETURNS>gboolean</RETURNS>
GskVulkanPushConstants         *self, const GskVulkanPushConstants   *src, const graphene_rect_t          *rect
</FUNCTION>
<FUNCTION>
<NAME>gsk_vulkan_push_constants_intersect_rounded</NAME>
<RETURNS>gboolean</RETURNS>
GskVulkanPushConstants         *self, const GskVulkanPushConstants   *src, const GskRoundedRect           *rect
</FUNCTION>
<FUNCTION>
<NAME>gsk_vulkan_push_constants_push</NAME>
<RETURNS>void</RETURNS>
const GskVulkanPushConstants   *self, VkCommandBuffer                 command_buffer, VkPipelineLayout                pipeline_layout
</FUNCTION>
<MACRO>
<NAME>GSK_TYPE_VULKAN_RENDERER</NAME>
#define GSK_TYPE_VULKAN_RENDERER (gsk_vulkan_renderer_get_type ())
</MACRO>
<MACRO>
<NAME>GSK_VULKAN_RENDERER</NAME>
#define GSK_VULKAN_RENDERER(obj)                 (G_TYPE_CHECK_INSTANCE_CAST ((obj), GSK_TYPE_VULKAN_RENDERER, GskVulkanRenderer))
</MACRO>
<MACRO>
<NAME>GSK_IS_VULKAN_RENDERER</NAME>
#define GSK_IS_VULKAN_RENDERER(obj)              (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GSK_TYPE_VULKAN_RENDERER))
</MACRO>
<MACRO>
<NAME>GSK_VULKAN_RENDERER_CLASS</NAME>
#define GSK_VULKAN_RENDERER_CLASS(klass)         (G_TYPE_CHECK_CLASS_CAST ((klass), GSK_TYPE_VULKAN_RENDERER, GskVulkanRendererClass))
</MACRO>
<MACRO>
<NAME>GSK_IS_VULKAN_RENDERER_CLASS</NAME>
#define GSK_IS_VULKAN_RENDERER_CLASS(klass)      (G_TYPE_CHECK_CLASS_TYPE ((klass), GSK_TYPE_VULKAN_RENDERER))
</MACRO>
<MACRO>
<NAME>GSK_VULKAN_RENDERER_GET_CLASS</NAME>
#define GSK_VULKAN_RENDERER_GET_CLASS(obj)       (G_TYPE_INSTANCE_GET_CLASS ((obj), GSK_TYPE_VULKAN_RENDERER, GskVulkanRendererClass))
</MACRO>
<FUNCTION>
<NAME>gsk_vulkan_renderer_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gsk_vulkan_renderer_new</NAME>
<RETURNS>GskRenderer *</RETURNS>
void
</FUNCTION>
<STRUCT>
<NAME>GskVulkanRenderer</NAME>
</STRUCT>
<STRUCT>
<NAME>GskVulkanRendererClass</NAME>
</STRUCT>
<FUNCTION>
<NAME>gsk_vulkan_renderer_ref_texture_image</NAME>
<RETURNS>GskVulkanImage *</RETURNS>
GskVulkanRenderer      *self, GdkTexture             *texture, GskVulkanUploader      *uploader
</FUNCTION>
<FUNCTION>
<NAME>gsk_vulkan_renderer_cache_glyph</NAME>
<RETURNS>guint</RETURNS>
GskVulkanRenderer *renderer, PangoFont         *font, PangoGlyph         glyph, int                x, int                y, float              scale
</FUNCTION>
<FUNCTION>
<NAME>gsk_vulkan_renderer_ref_glyph_image</NAME>
<RETURNS>GskVulkanImage *</RETURNS>
GskVulkanRenderer *self, GskVulkanUploader *uploader, guint              index
</FUNCTION>
<FUNCTION>
<NAME>gsk_vulkan_renderer_get_cached_glyph</NAME>
<RETURNS>GskVulkanCachedGlyph *</RETURNS>
GskVulkanRenderer *self, PangoFont         *font, PangoGlyph         glyph, int                x, int                y, float              scale
</FUNCTION>
<FUNCTION>
<NAME>gsk_vulkan_render_pass_new</NAME>
<RETURNS>GskVulkanRenderPass *</RETURNS>
GdkVulkanContext       *context, GskVulkanImage         *target, int                     scale_factor, graphene_matrix_t      *mv, graphene_rect_t        *viewport, cairo_region_t         *clip, VkSemaphore             signal_semaphore
</FUNCTION>
<FUNCTION>
<NAME>gsk_vulkan_render_pass_free</NAME>
<RETURNS>void</RETURNS>
GskVulkanRenderPass    *self
</FUNCTION>
<FUNCTION>
<NAME>gsk_vulkan_render_pass_add</NAME>
<RETURNS>void</RETURNS>
GskVulkanRenderPass    *self, GskVulkanRender        *render, GskRenderNode          *node
</FUNCTION>
<FUNCTION>
<NAME>gsk_vulkan_render_pass_upload</NAME>
<RETURNS>void</RETURNS>
GskVulkanRenderPass    *self, GskVulkanRender        *render, GskVulkanUploader      *uploader
</FUNCTION>
<FUNCTION>
<NAME>gsk_vulkan_render_pass_reserve_descriptor_sets</NAME>
<RETURNS>void</RETURNS>
GskVulkanRenderPass    *self, GskVulkanRender        *render
</FUNCTION>
<FUNCTION>
<NAME>gsk_vulkan_render_pass_draw</NAME>
<RETURNS>void</RETURNS>
GskVulkanRenderPass    *self, GskVulkanRender        *render, guint                   layout_count, VkPipelineLayout       *pipeline_layout, VkCommandBuffer         command_buffer
</FUNCTION>
<FUNCTION>
<NAME>gsk_vulkan_render_pass_get_wait_semaphores</NAME>
<RETURNS>gsize</RETURNS>
GskVulkanRenderPass    *self, VkSemaphore           **semaphores
</FUNCTION>
<FUNCTION>
<NAME>gsk_vulkan_render_pass_get_signal_semaphores</NAME>
<RETURNS>gsize</RETURNS>
GskVulkanRenderPass    *self, VkSemaphore           **semaphores
</FUNCTION>
<ENUM>
<NAME>GskVulkanPipelineType</NAME>
typedef enum {
  GSK_VULKAN_PIPELINE_TEXTURE,
  GSK_VULKAN_PIPELINE_TEXTURE_CLIP,
  GSK_VULKAN_PIPELINE_TEXTURE_CLIP_ROUNDED,
  GSK_VULKAN_PIPELINE_COLOR,
  GSK_VULKAN_PIPELINE_COLOR_CLIP,
  GSK_VULKAN_PIPELINE_COLOR_CLIP_ROUNDED,
  GSK_VULKAN_PIPELINE_LINEAR_GRADIENT,
  GSK_VULKAN_PIPELINE_LINEAR_GRADIENT_CLIP,
  GSK_VULKAN_PIPELINE_LINEAR_GRADIENT_CLIP_ROUNDED,
  GSK_VULKAN_PIPELINE_COLOR_MATRIX,
  GSK_VULKAN_PIPELINE_COLOR_MATRIX_CLIP,
  GSK_VULKAN_PIPELINE_COLOR_MATRIX_CLIP_ROUNDED,
  GSK_VULKAN_PIPELINE_BORDER,
  GSK_VULKAN_PIPELINE_BORDER_CLIP,
  GSK_VULKAN_PIPELINE_BORDER_CLIP_ROUNDED,
  GSK_VULKAN_PIPELINE_INSET_SHADOW,
  GSK_VULKAN_PIPELINE_INSET_SHADOW_CLIP,
  GSK_VULKAN_PIPELINE_INSET_SHADOW_CLIP_ROUNDED,
  GSK_VULKAN_PIPELINE_OUTSET_SHADOW,
  GSK_VULKAN_PIPELINE_OUTSET_SHADOW_CLIP,
  GSK_VULKAN_PIPELINE_OUTSET_SHADOW_CLIP_ROUNDED,
  GSK_VULKAN_PIPELINE_BLUR,
  GSK_VULKAN_PIPELINE_BLUR_CLIP,
  GSK_VULKAN_PIPELINE_BLUR_CLIP_ROUNDED,
  GSK_VULKAN_PIPELINE_TEXT,
  GSK_VULKAN_PIPELINE_TEXT_CLIP,
  GSK_VULKAN_PIPELINE_TEXT_CLIP_ROUNDED,
  GSK_VULKAN_PIPELINE_COLOR_TEXT,
  GSK_VULKAN_PIPELINE_COLOR_TEXT_CLIP,
  GSK_VULKAN_PIPELINE_COLOR_TEXT_CLIP_ROUNDED,
  GSK_VULKAN_PIPELINE_CROSS_FADE,
  GSK_VULKAN_PIPELINE_CROSS_FADE_CLIP,
  GSK_VULKAN_PIPELINE_CROSS_FADE_CLIP_ROUNDED,
  GSK_VULKAN_PIPELINE_BLEND_MODE,
  GSK_VULKAN_PIPELINE_BLEND_MODE_CLIP,
  GSK_VULKAN_PIPELINE_BLEND_MODE_CLIP_ROUNDED,
  /* add more */
  GSK_VULKAN_N_PIPELINES
} GskVulkanPipelineType;
</ENUM>
<FUNCTION>
<NAME>gsk_vulkan_render_new</NAME>
<RETURNS>GskVulkanRender *</RETURNS>
GskRenderer            *renderer, GdkVulkanContext       *context
</FUNCTION>
<FUNCTION>
<NAME>gsk_vulkan_render_free</NAME>
<RETURNS>void</RETURNS>
GskVulkanRender        *self
</FUNCTION>
<FUNCTION>
<NAME>gsk_vulkan_render_is_busy</NAME>
<RETURNS>gboolean</RETURNS>
GskVulkanRender        *self
</FUNCTION>
<FUNCTION>
<NAME>gsk_vulkan_render_reset</NAME>
<RETURNS>void</RETURNS>
GskVulkanRender        *self, GskVulkanImage         *target, const graphene_rect_t  *rect, const cairo_region_t   *clip
</FUNCTION>
<FUNCTION>
<NAME>gsk_vulkan_render_get_renderer</NAME>
<RETURNS>GskRenderer *</RETURNS>
GskVulkanRender        *self
</FUNCTION>
<FUNCTION>
<NAME>gsk_vulkan_render_add_cleanup_image</NAME>
<RETURNS>void</RETURNS>
GskVulkanRender        *self, GskVulkanImage         *image
</FUNCTION>
<FUNCTION>
<NAME>gsk_vulkan_render_add_node</NAME>
<RETURNS>void</RETURNS>
GskVulkanRender        *self, GskRenderNode          *node
</FUNCTION>
<FUNCTION>
<NAME>gsk_vulkan_render_add_render_pass</NAME>
<RETURNS>void</RETURNS>
GskVulkanRender        *self, GskVulkanRenderPass    *pass
</FUNCTION>
<FUNCTION>
<NAME>gsk_vulkan_render_upload</NAME>
<RETURNS>void</RETURNS>
GskVulkanRender        *self
</FUNCTION>
<FUNCTION>
<NAME>gsk_vulkan_render_get_pipeline</NAME>
<RETURNS>GskVulkanPipeline *</RETURNS>
GskVulkanRender        *self, GskVulkanPipelineType   pipeline_type
</FUNCTION>
<FUNCTION>
<NAME>gsk_vulkan_render_get_descriptor_set</NAME>
<RETURNS>VkDescriptorSet</RETURNS>
GskVulkanRender        *self, gsize                   id
</FUNCTION>
<FUNCTION>
<NAME>gsk_vulkan_render_reserve_descriptor_set</NAME>
<RETURNS>gsize</RETURNS>
GskVulkanRender        *self, GskVulkanImage         *source, gboolean                repeat
</FUNCTION>
<FUNCTION>
<NAME>gsk_vulkan_render_draw</NAME>
<RETURNS>void</RETURNS>
GskVulkanRender        *self
</FUNCTION>
<FUNCTION>
<NAME>gsk_vulkan_render_submit</NAME>
<RETURNS>void</RETURNS>
GskVulkanRender        *self
</FUNCTION>
<FUNCTION>
<NAME>gsk_vulkan_render_download_target</NAME>
<RETURNS>GdkTexture *</RETURNS>
GskVulkanRender        *self
</FUNCTION>
<FUNCTION>
<NAME>gsk_vulkan_render_get_framebuffer</NAME>
<RETURNS>VkFramebuffer</RETURNS>
GskVulkanRender        *self, GskVulkanImage         *image
</FUNCTION>
<ENUM>
<NAME>GskVulkanShaderType</NAME>
typedef enum {
  GSK_VULKAN_SHADER_VERTEX,
  GSK_VULKAN_SHADER_FRAGMENT
} GskVulkanShaderType;
</ENUM>
<MACRO>
<NAME>GST_VULKAN_SHADER_STAGE_CREATE_INFO</NAME>
#define GST_VULKAN_SHADER_STAGE_CREATE_INFO(shader) \
  (VkPipelineShaderStageCreateInfo) { \
  .sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO, \
  .stage = gsk_vulkan_shader_get_type (shader) == GSK_VULKAN_SHADER_VERTEX ? VK_SHADER_STAGE_VERTEX_BIT : VK_SHADER_STAGE_FRAGMENT_BIT, \
  .module = gsk_vulkan_shader_get_module (shader), \
  .pName = "main", \
}
</MACRO>
<FUNCTION>
<NAME>gsk_vulkan_shader_new_from_resource</NAME>
<RETURNS>GskVulkanShader *</RETURNS>
GdkVulkanContext       *context, GskVulkanShaderType     type, const char             *resource_name, GError                **error
</FUNCTION>
<FUNCTION>
<NAME>gsk_vulkan_shader_free</NAME>
<RETURNS>void</RETURNS>
GskVulkanShader        *shader
</FUNCTION>
<FUNCTION>
<NAME>gsk_vulkan_shader_get_type</NAME>
<RETURNS>GskVulkanShaderType</RETURNS>
GskVulkanShader        *shader
</FUNCTION>
<FUNCTION>
<NAME>gsk_vulkan_shader_get_module</NAME>
<RETURNS>VkShaderModule</RETURNS>
GskVulkanShader        *shader
</FUNCTION>
<STRUCT>
<NAME>GskVulkanShader</NAME>
</STRUCT>
<MACRO>
<NAME>GSK_TYPE_VULKAN_TEXT_PIPELINE</NAME>
#define GSK_TYPE_VULKAN_TEXT_PIPELINE (gsk_vulkan_text_pipeline_get_type ())
</MACRO>
<FUNCTION>
<NAME>gsk_vulkan_text_pipeline_new</NAME>
<RETURNS>GskVulkanPipeline *</RETURNS>
GdkVulkanContext              *context, VkPipelineLayout               layout, const char                    *shader_name, VkRenderPass                   render_pass
</FUNCTION>
<FUNCTION>
<NAME>gsk_vulkan_text_pipeline_count_vertex_data</NAME>
<RETURNS>gsize</RETURNS>
GskVulkanTextPipeline         *pipeline, int                            num_instances
</FUNCTION>
<FUNCTION>
<NAME>gsk_vulkan_text_pipeline_collect_vertex_data</NAME>
<RETURNS>void</RETURNS>
GskVulkanTextPipeline         *pipeline, guchar                         *data, GskVulkanRenderer              *renderer, const graphene_rect_t          *rect, PangoFont                      *font, guint                           total_glyphs, const PangoGlyphInfo           *glyphs, const GdkRGBA                  *color, const graphene_point_t         *offset, guint                           start_glyph, guint                           num_glyphs, float                           scale
</FUNCTION>
<FUNCTION>
<NAME>gsk_vulkan_text_pipeline_draw</NAME>
<RETURNS>gsize</RETURNS>
GskVulkanTextPipeline         *pipeline, VkCommandBuffer                 command_buffer, gsize                           offset, gsize                           n_commands
</FUNCTION>
<STRUCT>
<NAME>GskVulkanTextPipeline</NAME>
</STRUCT>
<STRUCT>
<NAME>GskVulkanTextPipelineLayout</NAME>
</STRUCT>
<MACRO>
<NAME>GSK_TYPE_VULKAN_TEXTURE_PIPELINE</NAME>
#define GSK_TYPE_VULKAN_TEXTURE_PIPELINE (gsk_vulkan_texture_pipeline_get_type ())
</MACRO>
<FUNCTION>
<NAME>gsk_vulkan_texture_pipeline_new</NAME>
<RETURNS>GskVulkanPipeline *</RETURNS>
GdkVulkanContext         *context, VkPipelineLayout          layout, const char               *shader_name, VkRenderPass              render_pass
</FUNCTION>
<FUNCTION>
<NAME>gsk_vulkan_texture_pipeline_count_vertex_data</NAME>
<RETURNS>gsize</RETURNS>
GskVulkanTexturePipeline *pipeline
</FUNCTION>
<FUNCTION>
<NAME>gsk_vulkan_texture_pipeline_collect_vertex_data</NAME>
<RETURNS>void</RETURNS>
GskVulkanTexturePipeline *pipeline, guchar                   *data, const graphene_rect_t    *rect, const graphene_rect_t    *tex_rect
</FUNCTION>
<FUNCTION>
<NAME>gsk_vulkan_texture_pipeline_draw</NAME>
<RETURNS>gsize</RETURNS>
GskVulkanTexturePipeline *pipeline, VkCommandBuffer           command_buffer, gsize                     offset, gsize                     n_commands
</FUNCTION>
<STRUCT>
<NAME>GskVulkanTexturePipeline</NAME>
</STRUCT>
<STRUCT>
<NAME>GskVulkanTexturePipelineLayout</NAME>
</STRUCT>
<MACRO>
<NAME>GSK_TYPE_RENDER_NODE_TYPE</NAME>
#define GSK_TYPE_RENDER_NODE_TYPE (gsk_render_node_type_get_type ())
</MACRO>
<MACRO>
<NAME>GSK_TYPE_SCALING_FILTER</NAME>
#define GSK_TYPE_SCALING_FILTER (gsk_scaling_filter_get_type ())
</MACRO>
<MACRO>
<NAME>GSK_TYPE_BLEND_MODE</NAME>
#define GSK_TYPE_BLEND_MODE (gsk_blend_mode_get_type ())
</MACRO>
<MACRO>
<NAME>GSK_TYPE_CORNER</NAME>
#define GSK_TYPE_CORNER (gsk_corner_get_type ())
</MACRO>
<MACRO>
<NAME>GSK_TYPE_SERIALIZATION_ERROR</NAME>
#define GSK_TYPE_SERIALIZATION_ERROR (gsk_serialization_error_get_type ())
</MACRO>
<MACRO>
<NAME>GSK_TYPE_TRANSFORM_CATEGORY</NAME>
#define GSK_TYPE_TRANSFORM_CATEGORY (gsk_transform_category_get_type ())
</MACRO>
