<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_RADIAL_GRADIENT_NODE,
  GSK_REPEATING_RADIAL_GRADIENT_NODE,
  GSK_CONIC_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,
  GSK_GL_SHADER_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>
<ENUM>
<NAME>GskGLUniformType</NAME>
typedef enum
{
  GSK_GL_UNIFORM_TYPE_NONE,
  GSK_GL_UNIFORM_TYPE_FLOAT,
  GSK_GL_UNIFORM_TYPE_INT,
  GSK_GL_UNIFORM_TYPE_UINT,
  GSK_GL_UNIFORM_TYPE_BOOL,
  GSK_GL_UNIFORM_TYPE_VEC2,
  GSK_GL_UNIFORM_TYPE_VEC3,
  GSK_GL_UNIFORM_TYPE_VEC4,
} GskGLUniformType;
</ENUM>
<MACRO>
<NAME>GSK_TYPE_SHADER_ARGS_BUILDER</NAME>
#define GSK_TYPE_SHADER_ARGS_BUILDER    (gsk_shader_args_builder_get_type ())
</MACRO>
<MACRO>
<NAME>GSK_TYPE_GL_SHADER</NAME>
#define GSK_TYPE_GL_SHADER (gsk_gl_shader_get_type ())
</MACRO>
<FUNCTION>
<NAME>gsk_gl_shader_new_from_bytes</NAME>
<RETURNS>GskGLShader *</RETURNS>
GBytes           *sourcecode
</FUNCTION>
<FUNCTION>
<NAME>gsk_gl_shader_new_from_resource</NAME>
<RETURNS>GskGLShader *</RETURNS>
const char       *resource_path
</FUNCTION>
<FUNCTION>
<NAME>gsk_gl_shader_compile</NAME>
<RETURNS>gboolean</RETURNS>
GskGLShader      *shader, GskRenderer      *renderer, GError          **error
</FUNCTION>
<FUNCTION>
<NAME>gsk_gl_shader_get_source</NAME>
<RETURNS>GBytes *</RETURNS>
GskGLShader      *shader
</FUNCTION>
<FUNCTION>
<NAME>gsk_gl_shader_get_resource</NAME>
<RETURNS>const char *</RETURNS>
GskGLShader      *shader
</FUNCTION>
<FUNCTION>
<NAME>gsk_gl_shader_get_n_textures</NAME>
<RETURNS>int</RETURNS>
GskGLShader      *shader
</FUNCTION>
<FUNCTION>
<NAME>gsk_gl_shader_get_n_uniforms</NAME>
<RETURNS>int</RETURNS>
GskGLShader      *shader
</FUNCTION>
<FUNCTION>
<NAME>gsk_gl_shader_get_uniform_name</NAME>
<RETURNS>const char *</RETURNS>
GskGLShader      *shader, int               idx
</FUNCTION>
<FUNCTION>
<NAME>gsk_gl_shader_find_uniform_by_name</NAME>
<RETURNS>int</RETURNS>
GskGLShader      *shader, const char       *name
</FUNCTION>
<FUNCTION>
<NAME>gsk_gl_shader_get_uniform_type</NAME>
<RETURNS>GskGLUniformType</RETURNS>
GskGLShader      *shader, int               idx
</FUNCTION>
<FUNCTION>
<NAME>gsk_gl_shader_get_uniform_offset</NAME>
<RETURNS>int</RETURNS>
GskGLShader      *shader, int               idx
</FUNCTION>
<FUNCTION>
<NAME>gsk_gl_shader_get_args_size</NAME>
<RETURNS>gsize</RETURNS>
GskGLShader      *shader
</FUNCTION>
<FUNCTION>
<NAME>gsk_gl_shader_format_args_va</NAME>
<RETURNS>GBytes *</RETURNS>
GskGLShader     *shader, va_list          uniforms
</FUNCTION>
<FUNCTION>
<NAME>gsk_gl_shader_format_args</NAME>
<RETURNS>GBytes *</RETURNS>
GskGLShader     *shader, ...
</FUNCTION>
<FUNCTION>
<NAME>gsk_gl_shader_get_arg_float</NAME>
<RETURNS>float</RETURNS>
GskGLShader     *shader, GBytes          *args, int              idx
</FUNCTION>
<FUNCTION>
<NAME>gsk_gl_shader_get_arg_int</NAME>
<RETURNS>gint32</RETURNS>
GskGLShader     *shader, GBytes          *args, int              idx
</FUNCTION>
<FUNCTION>
<NAME>gsk_gl_shader_get_arg_uint</NAME>
<RETURNS>guint32</RETURNS>
GskGLShader     *shader, GBytes          *args, int              idx
</FUNCTION>
<FUNCTION>
<NAME>gsk_gl_shader_get_arg_bool</NAME>
<RETURNS>gboolean</RETURNS>
GskGLShader     *shader, GBytes          *args, int              idx
</FUNCTION>
<FUNCTION>
<NAME>gsk_gl_shader_get_arg_vec2</NAME>
<RETURNS>void</RETURNS>
GskGLShader     *shader, GBytes          *args, int              idx, graphene_vec2_t *out_value
</FUNCTION>
<FUNCTION>
<NAME>gsk_gl_shader_get_arg_vec3</NAME>
<RETURNS>void</RETURNS>
GskGLShader     *shader, GBytes          *args, int              idx, graphene_vec3_t *out_value
</FUNCTION>
<FUNCTION>
<NAME>gsk_gl_shader_get_arg_vec4</NAME>
<RETURNS>void</RETURNS>
GskGLShader     *shader, GBytes          *args, int              idx, graphene_vec4_t *out_value
</FUNCTION>
<FUNCTION>
<NAME>gsk_shader_args_builder_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gsk_shader_args_builder_new</NAME>
<RETURNS>GskShaderArgsBuilder *</RETURNS>
GskGLShader *shader, GBytes      *initial_values
</FUNCTION>
<FUNCTION>
<NAME>gsk_shader_args_builder_to_args</NAME>
<RETURNS>GBytes *</RETURNS>
GskShaderArgsBuilder *builder
</FUNCTION>
<FUNCTION>
<NAME>gsk_shader_args_builder_free_to_args</NAME>
<RETURNS>GBytes *</RETURNS>
GskShaderArgsBuilder *builder
</FUNCTION>
<FUNCTION>
<NAME>gsk_shader_args_builder_ref</NAME>
<RETURNS>GskShaderArgsBuilder *</RETURNS>
GskShaderArgsBuilder *builder
</FUNCTION>
<FUNCTION>
<NAME>gsk_shader_args_builder_unref</NAME>
<RETURNS>void</RETURNS>
GskShaderArgsBuilder *builder
</FUNCTION>
<FUNCTION>
<NAME>gsk_shader_args_builder_set_float</NAME>
<RETURNS>void</RETURNS>
GskShaderArgsBuilder *builder, int                    idx, float                  value
</FUNCTION>
<FUNCTION>
<NAME>gsk_shader_args_builder_set_int</NAME>
<RETURNS>void</RETURNS>
GskShaderArgsBuilder *builder, int                    idx, gint32                 value
</FUNCTION>
<FUNCTION>
<NAME>gsk_shader_args_builder_set_uint</NAME>
<RETURNS>void</RETURNS>
GskShaderArgsBuilder *builder, int                    idx, guint32                value
</FUNCTION>
<FUNCTION>
<NAME>gsk_shader_args_builder_set_bool</NAME>
<RETURNS>void</RETURNS>
GskShaderArgsBuilder *builder, int                    idx, gboolean               value
</FUNCTION>
<FUNCTION>
<NAME>gsk_shader_args_builder_set_vec2</NAME>
<RETURNS>void</RETURNS>
GskShaderArgsBuilder *builder, int                    idx, const graphene_vec2_t *value
</FUNCTION>
<FUNCTION>
<NAME>gsk_shader_args_builder_set_vec3</NAME>
<RETURNS>void</RETURNS>
GskShaderArgsBuilder *builder, int                    idx, const graphene_vec3_t *value
</FUNCTION>
<FUNCTION>
<NAME>gsk_shader_args_builder_set_vec4</NAME>
<RETURNS>void</RETURNS>
GskShaderArgsBuilder *builder, int                    idx, const graphene_vec4_t *value
</FUNCTION>
<STRUCT>
<NAME>GskGLShader</NAME>
</STRUCT>
<STRUCT>
<NAME>GskShaderArgsBuilder</NAME>
</STRUCT>
<STRUCT>
<NAME>GskGLUniform</NAME>
typedef struct {
  char *name;
  GskGLUniformType type;
  gsize offset;
} GskGLUniform;
</STRUCT>
<FUNCTION>
<NAME>gsk_gl_shader_get_uniforms</NAME>
<RETURNS>const GskGLUniform *</RETURNS>
GskGLShader *shader, int         *n_uniforms
</FUNCTION>
<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>
<STRUCT>
<NAME>GskParseLocation</NAME>
struct _GskParseLocation
{
  gsize bytes;
  gsize chars;
  gsize lines;
  gsize line_bytes;
  gsize line_chars;
};
</STRUCT>
<USER_FUNCTION>
<NAME>GskParseErrorFunc</NAME>
<RETURNS>void</RETURNS>
const GskParseLocation *start, const GskParseLocation *end, 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_RADIAL_GRADIENT_NODE</NAME>
#define GSK_TYPE_RADIAL_GRADIENT_NODE           (gsk_radial_gradient_node_get_type())
</MACRO>
<MACRO>
<NAME>GSK_TYPE_REPEATING_RADIAL_GRADIENT_NODE</NAME>
#define GSK_TYPE_REPEATING_RADIAL_GRADIENT_NODE (gsk_repeating_radial_gradient_node_get_type())
</MACRO>
<MACRO>
<NAME>GSK_TYPE_CONIC_GRADIENT_NODE</NAME>
#define GSK_TYPE_CONIC_GRADIENT_NODE            (gsk_conic_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>
<MACRO>
<NAME>GSK_TYPE_GL_SHADER_NODE</NAME>
#define GSK_TYPE_GL_SHADER_NODE                 (gsk_gl_shader_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_get_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_get_start</NAME>
<RETURNS>const graphene_point_t *</RETURNS>
GskRenderNode            *node
</FUNCTION>
<FUNCTION>
<NAME>gsk_linear_gradient_node_get_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_get_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_conic_gradient_node_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gsk_conic_gradient_node_new</NAME>
<RETURNS>GskRenderNode *</RETURNS>
const graphene_rect_t    *bounds, const graphene_point_t   *center, float                     rotation, const GskColorStop       *color_stops, gsize                     n_color_stops
</FUNCTION>
<FUNCTION>
<NAME>gsk_conic_gradient_node_get_center</NAME>
<RETURNS>const graphene_point_t *</RETURNS>
GskRenderNode            *node
</FUNCTION>
<FUNCTION>
<NAME>gsk_conic_gradient_node_get_rotation</NAME>
<RETURNS>float</RETURNS>
GskRenderNode            *node
</FUNCTION>
<FUNCTION>
<NAME>gsk_conic_gradient_node_get_n_color_stops</NAME>
<RETURNS>gsize</RETURNS>
GskRenderNode            *node
</FUNCTION>
<FUNCTION>
<NAME>gsk_conic_gradient_node_get_color_stops</NAME>
<RETURNS>const GskColorStop *</RETURNS>
GskRenderNode            *node, gsize                    *n_stops
</FUNCTION>
<FUNCTION>
<NAME>gsk_radial_gradient_node_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gsk_radial_gradient_node_new</NAME>
<RETURNS>GskRenderNode *</RETURNS>
const graphene_rect_t    *bounds, const graphene_point_t   *center, float                     hradius, float                     vradius, float                     start, float                     end, const GskColorStop       *color_stops, gsize                     n_color_stops
</FUNCTION>
<FUNCTION>
<NAME>gsk_radial_gradient_node_get_n_color_stops</NAME>
<RETURNS>gsize</RETURNS>
GskRenderNode *node
</FUNCTION>
<FUNCTION>
<NAME>gsk_radial_gradient_node_get_color_stops</NAME>
<RETURNS>const GskColorStop *</RETURNS>
GskRenderNode *node, gsize         *n_stops
</FUNCTION>
<FUNCTION>
<NAME>gsk_radial_gradient_node_get_center</NAME>
<RETURNS>const graphene_point_t *</RETURNS>
GskRenderNode *node
</FUNCTION>
<FUNCTION>
<NAME>gsk_radial_gradient_node_get_hradius</NAME>
<RETURNS>float</RETURNS>
GskRenderNode *node
</FUNCTION>
<FUNCTION>
<NAME>gsk_radial_gradient_node_get_vradius</NAME>
<RETURNS>float</RETURNS>
GskRenderNode *node
</FUNCTION>
<FUNCTION>
<NAME>gsk_radial_gradient_node_get_start</NAME>
<RETURNS>float</RETURNS>
GskRenderNode *node
</FUNCTION>
<FUNCTION>
<NAME>gsk_radial_gradient_node_get_end</NAME>
<RETURNS>float</RETURNS>
GskRenderNode *node
</FUNCTION>
<FUNCTION>
<NAME>gsk_repeating_radial_gradient_node_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gsk_repeating_radial_gradient_node_new</NAME>
<RETURNS>GskRenderNode *</RETURNS>
const graphene_rect_t    *bounds, const graphene_point_t   *center, float                     hradius, float                     vradius, float                     start, float                     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_get_outline</NAME>
<RETURNS>const GskRoundedRect *</RETURNS>
GskRenderNode            *node
</FUNCTION>
<FUNCTION>
<NAME>gsk_border_node_get_widths</NAME>
<RETURNS>const float *</RETURNS>
GskRenderNode            *node
</FUNCTION>
<FUNCTION>
<NAME>gsk_border_node_get_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_get_outline</NAME>
<RETURNS>const GskRoundedRect *</RETURNS>
GskRenderNode            *node
</FUNCTION>
<FUNCTION>
<NAME>gsk_inset_shadow_node_get_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_get_outline</NAME>
<RETURNS>const GskRoundedRect *</RETURNS>
GskRenderNode            *node
</FUNCTION>
<FUNCTION>
<NAME>gsk_outset_shadow_node_get_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_get_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_get_color_matrix</NAME>
<RETURNS>const graphene_matrix_t *</RETURNS>
GskRenderNode            *node
</FUNCTION>
<FUNCTION>
<NAME>gsk_color_matrix_node_get_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_get_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_get_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_get_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_get_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_get_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_get_glyphs</NAME>
<RETURNS>const PangoGlyphInfo *</RETURNS>
GskRenderNode            *node, guint                    *n_glyphs
</FUNCTION>
<FUNCTION>
<NAME>gsk_text_node_get_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>
<FUNCTION>
<NAME>gsk_gl_shader_node_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gsk_gl_shader_node_new</NAME>
<RETURNS>GskRenderNode *</RETURNS>
GskGLShader              *shader, const graphene_rect_t    *bounds, GBytes                   *args, GskRenderNode           **children, guint                     n_children
</FUNCTION>
<FUNCTION>
<NAME>gsk_gl_shader_node_get_n_children</NAME>
<RETURNS>guint</RETURNS>
GskRenderNode            *node
</FUNCTION>
<FUNCTION>
<NAME>gsk_gl_shader_node_get_child</NAME>
<RETURNS>GskRenderNode *</RETURNS>
GskRenderNode            *node, guint                     idx
</FUNCTION>
<FUNCTION>
<NAME>gsk_gl_shader_node_get_args</NAME>
<RETURNS>GBytes *</RETURNS>
GskRenderNode            *node
</FUNCTION>
<FUNCTION>
<NAME>gsk_gl_shader_node_get_shader</NAME>
<RETURNS>GskGLShader *</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>GskConicGradientNode</NAME>
</STRUCT>
<STRUCT>
<NAME>GskContainerNode</NAME>
</STRUCT>
<STRUCT>
<NAME>GskCrossFadeNode</NAME>
</STRUCT>
<STRUCT>
<NAME>GskDebugNode</NAME>
</STRUCT>
<STRUCT>
<NAME>GskGLShaderNode</NAME>
</STRUCT>
<STRUCT>
<NAME>GskInsetShadowNode</NAME>
</STRUCT>
<STRUCT>
<NAME>GskLinearGradientNode</NAME>
</STRUCT>
<STRUCT>
<NAME>GskOpacityNode</NAME>
</STRUCT>
<STRUCT>
<NAME>GskOutsetShadowNode</NAME>
</STRUCT>
<STRUCT>
<NAME>GskRadialGradientNode</NAME>
</STRUCT>
<STRUCT>
<NAME>GskRenderNode</NAME>
</STRUCT>
<STRUCT>
<NAME>GskRepeatNode</NAME>
</STRUCT>
<STRUCT>
<NAME>GskRepeatingLinearGradientNode</NAME>
</STRUCT>
<STRUCT>
<NAME>GskRepeatingRadialGradientNode</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>
<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_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 15
</MACRO>
<MACRO>
<NAME>GL_MAX_GRADIENT_STOPS</NAME>
#define GL_MAX_GRADIENT_STOPS 6
</MACRO>
<STRUCT>
<NAME>Program</NAME>
struct _Program
{
  const char *name;

  int index;        /* Into the renderer's program array -1 for custom */

  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 num_color_stops_location;
      int color_stops_location;
      int center_location;
      int start_location;
      int end_location;
      int radius_location;
    } radial_gradient;
    struct {
      int num_color_stops_location;
      int color_stops_location;
      int center_location;
      int rotation_location;
    } conic_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 {
      int size_location;
      int args_locations[8];
      int texture_locations[4];
      GError *compile_error;
    } glshader;
  };
  ProgramState state;
};
</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 radial_gradient_program;
      Program conic_gradient_program;
      Program outset_shadow_program;
      Program repeat_program;
      Program unblurred_outset_shadow_program;
    };
  };
  GHashTable *custom_programs; /* GskGLShader -> Program* */
} 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, 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_extra_texture</NAME>
<RETURNS>void</RETURNS>
RenderOpBuilder         *builder, int                      texture_id, int                      idx
</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_gl_shader_args</NAME>
<RETURNS>void</RETURNS>
RenderOpBuilder         *builder, GskGLShader             *shader, float                    width, float                    height, const guchar            *uniform_data
</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_set_radial_gradient</NAME>
<RETURNS>void</RETURNS>
RenderOpBuilder        *self, guint                   n_color_stops, const GskColorStop     *color_stops, float                   center_x, float                   center_y, float                   start, float                   end, float                   hradius, float                   vradius
</FUNCTION>
<FUNCTION>
<NAME>ops_set_conic_gradient</NAME>
<RETURNS>void</RETURNS>
RenderOpBuilder        *self, guint                   n_color_stops, const GskColorStop     *color_stops, float                   center_x, float                   center_y, float                   rotation
</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, const char          *extra_fragment_snippet, gsize                extra_fragment_length, 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_RADIAL_GRADIENT            = 12,
  OP_CHANGE_COLOR_MATRIX               = 13,
  OP_CHANGE_BLUR                       = 14,
  OP_CHANGE_INSET_SHADOW               = 15,
  OP_CHANGE_OUTSET_SHADOW              = 16,
  OP_CHANGE_BORDER                     = 17,
  OP_CHANGE_BORDER_COLOR               = 18,
  OP_CHANGE_BORDER_WIDTH               = 19,
  OP_CHANGE_CROSS_FADE                 = 20,
  OP_CHANGE_UNBLURRED_OUTSET_SHADOW    = 21,
  OP_CLEAR                             = 22,
  OP_DRAW                              = 23,
  OP_DUMP_FRAMEBUFFER                  = 24,
  OP_PUSH_DEBUG_GROUP                  = 25,
  OP_POP_DEBUG_GROUP                   = 26,
  OP_CHANGE_BLEND                      = 27,
  OP_CHANGE_GL_SHADER_ARGS             = 28,
  OP_CHANGE_EXTRA_SOURCE_TEXTURE       = 29,
  OP_CHANGE_CONIC_GRADIENT             = 30,
  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_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>
<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_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_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>
<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>
<MACRO>
<NAME>GSK_TYPE_GL_UNIFORM_TYPE</NAME>
#define GSK_TYPE_GL_UNIFORM_TYPE (gsk_gl_uniform_type_get_type ())
</MACRO>
