<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>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>
<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>
const 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>
const GskRenderNode      *node
</FUNCTION>
<FUNCTION>
<NAME>gsk_debug_node_get_message</NAME>
<RETURNS>const char *</RETURNS>
const 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>
const 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>
const 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>
const GskRenderNode      *node
</FUNCTION>
<FUNCTION>
<NAME>gsk_linear_gradient_node_get_end</NAME>
<RETURNS>const graphene_point_t *</RETURNS>
const GskRenderNode      *node
</FUNCTION>
<FUNCTION>
<NAME>gsk_linear_gradient_node_get_n_color_stops</NAME>
<RETURNS>gsize</RETURNS>
const GskRenderNode      *node
</FUNCTION>
<FUNCTION>
<NAME>gsk_linear_gradient_node_get_color_stops</NAME>
<RETURNS>const GskColorStop *</RETURNS>
const 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>
const GskRenderNode      *node
</FUNCTION>
<FUNCTION>
<NAME>gsk_conic_gradient_node_get_rotation</NAME>
<RETURNS>float</RETURNS>
const GskRenderNode      *node
</FUNCTION>
<FUNCTION>
<NAME>gsk_conic_gradient_node_get_angle</NAME>
<RETURNS>float</RETURNS>
const GskRenderNode      *node
</FUNCTION>
<FUNCTION>
<NAME>gsk_conic_gradient_node_get_n_color_stops</NAME>
<RETURNS>gsize</RETURNS>
const GskRenderNode      *node
</FUNCTION>
<FUNCTION>
<NAME>gsk_conic_gradient_node_get_color_stops</NAME>
<RETURNS>const GskColorStop *</RETURNS>
const 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>
const GskRenderNode *node
</FUNCTION>
<FUNCTION>
<NAME>gsk_radial_gradient_node_get_color_stops</NAME>
<RETURNS>const GskColorStop *</RETURNS>
const GskRenderNode *node, gsize               *n_stops
</FUNCTION>
<FUNCTION>
<NAME>gsk_radial_gradient_node_get_center</NAME>
<RETURNS>const graphene_point_t *</RETURNS>
const GskRenderNode *node
</FUNCTION>
<FUNCTION>
<NAME>gsk_radial_gradient_node_get_hradius</NAME>
<RETURNS>float</RETURNS>
const GskRenderNode *node
</FUNCTION>
<FUNCTION>
<NAME>gsk_radial_gradient_node_get_vradius</NAME>
<RETURNS>float</RETURNS>
const GskRenderNode *node
</FUNCTION>
<FUNCTION>
<NAME>gsk_radial_gradient_node_get_start</NAME>
<RETURNS>float</RETURNS>
const GskRenderNode *node
</FUNCTION>
<FUNCTION>
<NAME>gsk_radial_gradient_node_get_end</NAME>
<RETURNS>float</RETURNS>
const 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>
const GskRenderNode      *node
</FUNCTION>
<FUNCTION>
<NAME>gsk_border_node_get_widths</NAME>
<RETURNS>const float *</RETURNS>
const GskRenderNode      *node
</FUNCTION>
<FUNCTION>
<NAME>gsk_border_node_get_colors</NAME>
<RETURNS>const GdkRGBA *</RETURNS>
const 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>
const GskRenderNode      *node
</FUNCTION>
<FUNCTION>
<NAME>gsk_inset_shadow_node_get_color</NAME>
<RETURNS>const GdkRGBA *</RETURNS>
const GskRenderNode      *node
</FUNCTION>
<FUNCTION>
<NAME>gsk_inset_shadow_node_get_dx</NAME>
<RETURNS>float</RETURNS>
const GskRenderNode      *node
</FUNCTION>
<FUNCTION>
<NAME>gsk_inset_shadow_node_get_dy</NAME>
<RETURNS>float</RETURNS>
const GskRenderNode      *node
</FUNCTION>
<FUNCTION>
<NAME>gsk_inset_shadow_node_get_spread</NAME>
<RETURNS>float</RETURNS>
const GskRenderNode      *node
</FUNCTION>
<FUNCTION>
<NAME>gsk_inset_shadow_node_get_blur_radius</NAME>
<RETURNS>float</RETURNS>
const 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>
const GskRenderNode      *node
</FUNCTION>
<FUNCTION>
<NAME>gsk_outset_shadow_node_get_color</NAME>
<RETURNS>const GdkRGBA *</RETURNS>
const GskRenderNode      *node
</FUNCTION>
<FUNCTION>
<NAME>gsk_outset_shadow_node_get_dx</NAME>
<RETURNS>float</RETURNS>
const GskRenderNode      *node
</FUNCTION>
<FUNCTION>
<NAME>gsk_outset_shadow_node_get_dy</NAME>
<RETURNS>float</RETURNS>
const GskRenderNode      *node
</FUNCTION>
<FUNCTION>
<NAME>gsk_outset_shadow_node_get_spread</NAME>
<RETURNS>float</RETURNS>
const GskRenderNode      *node
</FUNCTION>
<FUNCTION>
<NAME>gsk_outset_shadow_node_get_blur_radius</NAME>
<RETURNS>float</RETURNS>
const 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>
const GskRenderNode      *node
</FUNCTION>
<FUNCTION>
<NAME>gsk_container_node_get_child</NAME>
<RETURNS>GskRenderNode *</RETURNS>
const 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>
const GskRenderNode      *node
</FUNCTION>
<FUNCTION>
<NAME>gsk_transform_node_get_transform</NAME>
<RETURNS>GskTransform *</RETURNS>
const 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>
const GskRenderNode      *node
</FUNCTION>
<FUNCTION>
<NAME>gsk_opacity_node_get_opacity</NAME>
<RETURNS>float</RETURNS>
const 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>
const GskRenderNode      *node
</FUNCTION>
<FUNCTION>
<NAME>gsk_color_matrix_node_get_color_matrix</NAME>
<RETURNS>const graphene_matrix_t *</RETURNS>
const GskRenderNode      *node
</FUNCTION>
<FUNCTION>
<NAME>gsk_color_matrix_node_get_color_offset</NAME>
<RETURNS>const graphene_vec4_t *</RETURNS>
const 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>
const GskRenderNode      *node
</FUNCTION>
<FUNCTION>
<NAME>gsk_repeat_node_get_child_bounds</NAME>
<RETURNS>const graphene_rect_t *</RETURNS>
const 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>
const GskRenderNode      *node
</FUNCTION>
<FUNCTION>
<NAME>gsk_clip_node_get_clip</NAME>
<RETURNS>const graphene_rect_t *</RETURNS>
const 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>
const GskRenderNode      *node
</FUNCTION>
<FUNCTION>
<NAME>gsk_rounded_clip_node_get_clip</NAME>
<RETURNS>const GskRoundedRect *</RETURNS>
const 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>
const GskRenderNode      *node
</FUNCTION>
<FUNCTION>
<NAME>gsk_shadow_node_get_shadow</NAME>
<RETURNS>const GskShadow *</RETURNS>
const GskRenderNode      *node, gsize                     i
</FUNCTION>
<FUNCTION>
<NAME>gsk_shadow_node_get_n_shadows</NAME>
<RETURNS>gsize</RETURNS>
const 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>
const GskRenderNode      *node
</FUNCTION>
<FUNCTION>
<NAME>gsk_blend_node_get_top_child</NAME>
<RETURNS>GskRenderNode *</RETURNS>
const GskRenderNode      *node
</FUNCTION>
<FUNCTION>
<NAME>gsk_blend_node_get_blend_mode</NAME>
<RETURNS>GskBlendMode</RETURNS>
const 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>
const GskRenderNode      *node
</FUNCTION>
<FUNCTION>
<NAME>gsk_cross_fade_node_get_end_child</NAME>
<RETURNS>GskRenderNode *</RETURNS>
const GskRenderNode      *node
</FUNCTION>
<FUNCTION>
<NAME>gsk_cross_fade_node_get_progress</NAME>
<RETURNS>float</RETURNS>
const 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>
const GskRenderNode      *node
</FUNCTION>
<FUNCTION>
<NAME>gsk_text_node_has_color_glyphs</NAME>
<RETURNS>gboolean</RETURNS>
const GskRenderNode      *node
</FUNCTION>
<FUNCTION>
<NAME>gsk_text_node_get_num_glyphs</NAME>
<RETURNS>guint</RETURNS>
const GskRenderNode      *node
</FUNCTION>
<FUNCTION>
<NAME>gsk_text_node_get_glyphs</NAME>
<RETURNS>const PangoGlyphInfo *</RETURNS>
const GskRenderNode      *node, guint                    *n_glyphs
</FUNCTION>
<FUNCTION>
<NAME>gsk_text_node_get_color</NAME>
<RETURNS>const GdkRGBA *</RETURNS>
const GskRenderNode      *node
</FUNCTION>
<FUNCTION>
<NAME>gsk_text_node_get_offset</NAME>
<RETURNS>const graphene_point_t *</RETURNS>
const 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>
const GskRenderNode      *node
</FUNCTION>
<FUNCTION>
<NAME>gsk_blur_node_get_radius</NAME>
<RETURNS>float</RETURNS>
const 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>
const GskRenderNode      *node
</FUNCTION>
<FUNCTION>
<NAME>gsk_gl_shader_node_get_child</NAME>
<RETURNS>GskRenderNode *</RETURNS>
const GskRenderNode      *node, guint                     idx
</FUNCTION>
<FUNCTION>
<NAME>gsk_gl_shader_node_get_args</NAME>
<RETURNS>GBytes *</RETURNS>
const GskRenderNode      *node
</FUNCTION>
<FUNCTION>
<NAME>gsk_gl_shader_node_get_shader</NAME>
<RETURNS>GskGLShader *</RETURNS>
const 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>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>
<STRUCT>
<NAME>GskNglBindTexture</NAME>
struct _GskNglBindTexture
{
  guint changed : 1;
  guint initial : 1;
  GLenum target : 30;
  GLenum texture;
  guint id;
};
</STRUCT>
<FUNCTION>
<NAME>sizeof</NAME>
<RETURNS>G_STATIC_ASSERT</RETURNS>
GskNglBindTexture) == 12
</FUNCTION>
<STRUCT>
<NAME>GskNglBindFramebuffer</NAME>
struct _GskNglBindFramebuffer
{
  guint changed : 1;
  guint id : 31;
};
</STRUCT>
<STRUCT>
<NAME>GskNglAttachmentState</NAME>
struct _GskNglAttachmentState
{
  GskNglBindFramebuffer fbo;
  /* Increase if shaders add more textures */
  GskNglBindTexture textures[4];
  guint n_changed;
};
</STRUCT>
<FUNCTION>
<NAME>gsk_ngl_attachment_state_new</NAME>
<RETURNS>GskNglAttachmentState *</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gsk_ngl_attachment_state_ref</NAME>
<RETURNS>GskNglAttachmentState *</RETURNS>
GskNglAttachmentState *self
</FUNCTION>
<FUNCTION>
<NAME>gsk_ngl_attachment_state_unref</NAME>
<RETURNS>void</RETURNS>
GskNglAttachmentState *self
</FUNCTION>
<FUNCTION>
<NAME>gsk_ngl_attachment_state_bind_texture</NAME>
<RETURNS>void</RETURNS>
GskNglAttachmentState *self, GLenum                 target, GLenum                 texture, guint                  id
</FUNCTION>
<FUNCTION>
<NAME>gsk_ngl_attachment_state_bind_framebuffer</NAME>
<RETURNS>void</RETURNS>
GskNglAttachmentState *self, guint                  id
</FUNCTION>
<FUNCTION>
<NAME>gsk_ngl_buffer_init</NAME>
<RETURNS>void</RETURNS>
GskNglBuffer *self, GLenum        target, guint         element_size
</FUNCTION>
<FUNCTION>
<NAME>gsk_ngl_buffer_destroy</NAME>
<RETURNS>void</RETURNS>
GskNglBuffer *buffer
</FUNCTION>
<FUNCTION>
<NAME>gsk_ngl_buffer_submit</NAME>
<RETURNS>GLuint</RETURNS>
GskNglBuffer *buffer
</FUNCTION>
<FUNCTION>
<NAME>gsk_ngl_buffer_advance</NAME>
<RETURNS>gpointer</RETURNS>
GskNglBuffer *buffer, guint         count
</FUNCTION>
<FUNCTION>
<NAME>gsk_ngl_buffer_retract</NAME>
<RETURNS>void</RETURNS>
GskNglBuffer *buffer, guint         count
</FUNCTION>
<FUNCTION>
<NAME>gsk_ngl_buffer_get_offset</NAME>
<RETURNS>guint</RETURNS>
GskNglBuffer *buffer
</FUNCTION>
<MACRO>
<NAME>GSK_TYPE_GL_COMMAND_QUEUE</NAME>
#define GSK_TYPE_GL_COMMAND_QUEUE (gsk_ngl_command_queue_get_type())
</MACRO>
<ENUM>
<NAME>GskNglCommandKind</NAME>
typedef enum _GskNglCommandKind
{
  /* The batch will perform a glClear() */
  GSK_NGL_COMMAND_KIND_CLEAR,

  /* The batch will perform a glDrawArrays() */
  GSK_NGL_COMMAND_KIND_DRAW,
} GskNglCommandKind;
</ENUM>
<FUNCTION>
<NAME>sizeof</NAME>
<RETURNS>G_STATIC_ASSERT</RETURNS>
GskNglCommandBind) == 4
</FUNCTION>
<STRUCT>
<NAME>GskNglCommandQueue</NAME>
struct _GskNglCommandQueue
{
  GObject parent_instance;

  /* The GdkGLContext we make current before executing GL commands. */
  GdkGLContext *context;

  /* Array of GskNglCommandBatch which is a fixed size structure that will
   * point into offsets of other arrays so that all similar data is stored
   * together. The idea here is that we reduce the need for pointers so that
   * using g_realloc()'d arrays is fine.
   */
  GskNglCommandBatches batches;

  /* Contains array of vertices and some wrapper code to help upload them
   * to the GL driver. We can also tweak this to use double buffered arrays
   * if we find that to be faster on some hardware and/or drivers.
   */
  GskNglBuffer vertices;

  /* The GskNglAttachmentState contains information about our FBO and texture
   * attachments as we process incoming operations. We snapshot them into
   * various batches so that we can compare differences between merge
   * candidates.
   */
  GskNglAttachmentState *attachments;

  /* The uniform state across all programs. We snapshot this into batches so
   * that we can compare uniform state between batches to give us more
   * chances at merging draw commands.
   */
  GskNglUniformState *uniforms;

  /* Current program if we are in a draw so that we can send commands
   * to the uniform state as needed.
   */
  GskNglUniformProgram *program_info;

  /* The profiler instance to deliver timing/etc data */
  GskProfiler *profiler;
  GskGLProfiler *gl_profiler;

  /* Array of GskNglCommandBind which denote what textures need to be attached
   * to which slot. GskNglCommandDraw.bind_offset and bind_count reference this
   * array to determine what to attach.
   */
  GskNglCommandBinds batch_binds;

  /* Array of GskNglCommandUniform denoting which uniforms must be updated
   * before the glDrawArrays() may be called. These are referenced from the
   * GskNglCommandDraw.uniform_offset and uniform_count fields.
   */
  GskNglCommandUniforms batch_uniforms;

  /* String storage for debug groups */
  GStringChunk *debug_groups;

  /* Discovered max texture size when loading the command queue so that we
   * can either scale down or slice textures to fit within this size. Assumed
   * to be both height and width.
   */
  int max_texture_size;

  /* The index of the last batch in @batches, which may not be the element
   * at the end of the array, as batches can be reordered. This is used to
   * update the "next" index when adding a new batch.
   */
  gint16 tail_batch_index;
  gint16 head_batch_index;

  /* Max framebuffer we used, so we can sort items faster */
  guint fbo_max;

  /* Various GSK and GDK metric counter ids */
  struct {
    GQuark n_frames;
    GQuark cpu_time;
    GQuark gpu_time;
    guint n_binds;
    guint n_fbos;
    guint n_uniforms;
    guint n_uploads;
    guint queue_depth;
  } metrics;

  /* Counter for uploads on the frame */
  guint n_uploads;

  /* If we're inside a begin/end_frame pair */
  guint in_frame : 1;

  /* If we're inside of a begin_draw()/end_draw() pair. */
  guint in_draw : 1;

  /* If we've warned about truncating batches */
  guint have_truncated : 1;
};
</STRUCT>
<FUNCTION>
<NAME>gsk_ngl_command_queue_new</NAME>
<RETURNS>GskNglCommandQueue *</RETURNS>
GdkGLContext          *context, GskNglUniformState    *uniforms
</FUNCTION>
<FUNCTION>
<NAME>gsk_ngl_command_queue_set_profiler</NAME>
<RETURNS>void</RETURNS>
GskNglCommandQueue    *self, GskProfiler           *profiler
</FUNCTION>
<FUNCTION>
<NAME>gsk_ngl_command_queue_get_context</NAME>
<RETURNS>GdkGLContext *</RETURNS>
GskNglCommandQueue    *self
</FUNCTION>
<FUNCTION>
<NAME>gsk_ngl_command_queue_make_current</NAME>
<RETURNS>void</RETURNS>
GskNglCommandQueue    *self
</FUNCTION>
<FUNCTION>
<NAME>gsk_ngl_command_queue_begin_frame</NAME>
<RETURNS>void</RETURNS>
GskNglCommandQueue    *self
</FUNCTION>
<FUNCTION>
<NAME>gsk_ngl_command_queue_end_frame</NAME>
<RETURNS>void</RETURNS>
GskNglCommandQueue    *self
</FUNCTION>
<FUNCTION>
<NAME>gsk_ngl_command_queue_execute</NAME>
<RETURNS>void</RETURNS>
GskNglCommandQueue    *self, guint                  surface_height, guint                  scale_factor, const cairo_region_t  *scissor
</FUNCTION>
<FUNCTION>
<NAME>gsk_ngl_command_queue_upload_texture</NAME>
<RETURNS>int</RETURNS>
GskNglCommandQueue    *self, GdkTexture            *texture, guint                  x_offset, guint                  y_offset, guint                  width, guint                  height, int                    min_filter, int                    mag_filter
</FUNCTION>
<FUNCTION>
<NAME>gsk_ngl_command_queue_create_texture</NAME>
<RETURNS>int</RETURNS>
GskNglCommandQueue    *self, int                    width, int                    height, int                    min_filter, int                    mag_filter
</FUNCTION>
<FUNCTION>
<NAME>gsk_ngl_command_queue_create_framebuffer</NAME>
<RETURNS>guint</RETURNS>
GskNglCommandQueue    *self
</FUNCTION>
<FUNCTION>
<NAME>gsk_ngl_command_queue_create_render_target</NAME>
<RETURNS>gboolean</RETURNS>
GskNglCommandQueue    *self, int                    width, int                    height, int                    min_filter, int                    mag_filter, guint                 *out_fbo_id, guint                 *out_texture_id
</FUNCTION>
<FUNCTION>
<NAME>gsk_ngl_command_queue_delete_program</NAME>
<RETURNS>void</RETURNS>
GskNglCommandQueue    *self, guint                  program_id
</FUNCTION>
<FUNCTION>
<NAME>gsk_ngl_command_queue_clear</NAME>
<RETURNS>void</RETURNS>
GskNglCommandQueue    *self, guint                  clear_bits, const graphene_rect_t *viewport
</FUNCTION>
<FUNCTION>
<NAME>gsk_ngl_command_queue_begin_draw</NAME>
<RETURNS>void</RETURNS>
GskNglCommandQueue    *self, GskNglUniformProgram  *program_info, guint                  width, guint                  height
</FUNCTION>
<FUNCTION>
<NAME>gsk_ngl_command_queue_end_draw</NAME>
<RETURNS>void</RETURNS>
GskNglCommandQueue    *self
</FUNCTION>
<FUNCTION>
<NAME>gsk_ngl_command_queue_split_draw</NAME>
<RETURNS>void</RETURNS>
GskNglCommandQueue    *self
</FUNCTION>
<FUNCTION>
<NAME>gsk_ngl_command_queue_get_batch</NAME>
<RETURNS>GskNglCommandBatch *</RETURNS>
GskNglCommandQueue *self
</FUNCTION>
<FUNCTION>
<NAME>gsk_ngl_command_queue_add_vertices</NAME>
<RETURNS>GskNglDrawVertex *</RETURNS>
GskNglCommandQueue *self
</FUNCTION>
<FUNCTION>
<NAME>gsk_ngl_command_queue_add_n_vertices</NAME>
<RETURNS>GskNglDrawVertex *</RETURNS>
GskNglCommandQueue *self, guint               count
</FUNCTION>
<FUNCTION>
<NAME>gsk_ngl_command_queue_retract_n_vertices</NAME>
<RETURNS>void</RETURNS>
GskNglCommandQueue *self, guint               count
</FUNCTION>
<FUNCTION>
<NAME>gsk_ngl_command_queue_bind_framebuffer</NAME>
<RETURNS>guint</RETURNS>
GskNglCommandQueue *self, guint               framebuffer
</FUNCTION>
<ENUM>
<NAME>GskNglCompilerKind</NAME>
typedef enum _GskNglCompilerKind
{
  GSK_NGL_COMPILER_ALL,
  GSK_NGL_COMPILER_FRAGMENT,
  GSK_NGL_COMPILER_VERTEX,
} GskNglCompilerKind;
</ENUM>
<MACRO>
<NAME>GSK_TYPE_GL_COMPILER</NAME>
#define GSK_TYPE_GL_COMPILER (gsk_ngl_compiler_get_type())
</MACRO>
<FUNCTION>
<NAME>gsk_ngl_compiler_new</NAME>
<RETURNS>GskNglCompiler *</RETURNS>
GskNglDriver        *driver, gboolean             debug
</FUNCTION>
<FUNCTION>
<NAME>gsk_ngl_compiler_set_preamble</NAME>
<RETURNS>void</RETURNS>
GskNglCompiler      *self, GskNglCompilerKind   kind, GBytes              *preamble_bytes
</FUNCTION>
<FUNCTION>
<NAME>gsk_ngl_compiler_set_preamble_from_resource</NAME>
<RETURNS>void</RETURNS>
GskNglCompiler      *self, GskNglCompilerKind   kind, const char          *resource_path
</FUNCTION>
<FUNCTION>
<NAME>gsk_ngl_compiler_set_source</NAME>
<RETURNS>void</RETURNS>
GskNglCompiler      *self, GskNglCompilerKind   kind, GBytes              *source_bytes
</FUNCTION>
<FUNCTION>
<NAME>gsk_ngl_compiler_set_source_from_resource</NAME>
<RETURNS>void</RETURNS>
GskNglCompiler      *self, GskNglCompilerKind   kind, const char          *resource_path
</FUNCTION>
<FUNCTION>
<NAME>gsk_ngl_compiler_set_suffix</NAME>
<RETURNS>void</RETURNS>
GskNglCompiler      *self, GskNglCompilerKind   kind, GBytes              *suffix_bytes
</FUNCTION>
<FUNCTION>
<NAME>gsk_ngl_compiler_set_suffix_from_resource</NAME>
<RETURNS>void</RETURNS>
GskNglCompiler      *self, GskNglCompilerKind   kind, const char          *resource_path
</FUNCTION>
<FUNCTION>
<NAME>gsk_ngl_compiler_bind_attribute</NAME>
<RETURNS>void</RETURNS>
GskNglCompiler      *self, const char          *name, guint                location
</FUNCTION>
<FUNCTION>
<NAME>gsk_ngl_compiler_clear_attributes</NAME>
<RETURNS>void</RETURNS>
GskNglCompiler      *self
</FUNCTION>
<FUNCTION>
<NAME>gsk_ngl_compiler_compile</NAME>
<RETURNS>GskNglProgram *</RETURNS>
GskNglCompiler      *self, const char          *name, GError             **error
</FUNCTION>
<STRUCT>
<NAME>GskNglCompiler</NAME>
</STRUCT>
<STRUCT>
<NAME>GskTextureKey</NAME>
typedef struct {
  gconstpointer   pointer;
  float           scale_x;
  float           scale_y;
  int             filter;
  int             pointer_is_child;
  graphene_rect_t parent_rect; /* Valid when pointer_is_child */
} GskTextureKey;
</STRUCT>
<MACRO>
<NAME>GSL_GK_NO_UNIFORMS</NAME>
#define GSL_GK_NO_UNIFORMS UNIFORM_INVALID_##__COUNTER__
</MACRO>
<MACRO>
<NAME>GSK_NGL_ADD_UNIFORM</NAME>
#define GSK_NGL_ADD_UNIFORM(pos, KEY, name) UNIFORM_##KEY = UNIFORM_SHARED_LAST + pos,
</MACRO>
<MACRO>
<NAME>GSK_NGL_DEFINE_PROGRAM</NAME>
#define GSK_NGL_DEFINE_PROGRAM(name, resource, uniforms) enum { uniforms };
</MACRO>
<MACRO>
<NAME>GSK_TYPE_NGL_DRIVER</NAME>
#define GSK_TYPE_NGL_DRIVER (gsk_ngl_driver_get_type())
</MACRO>
<STRUCT>
<NAME>GskNglRenderTarget</NAME>
struct _GskNglRenderTarget
{
  guint framebuffer_id;
  guint texture_id;
  int min_filter;
  int mag_filter;
  int width;
  int height;
};
</STRUCT>
<STRUCT>
<NAME>GskNglDriver</NAME>
struct _GskNglDriver
{
  GObject parent_instance;

  GskNglCommandQueue *shared_command_queue;
  GskNglCommandQueue *command_queue;

  GskNglTexturePool texture_pool;

  GskNglGlyphLibrary *glyphs;
  GskNglIconLibrary *icons;
  GskNglShadowLibrary *shadows;

  GHashTable *textures;
  GHashTable *key_to_texture_id;
  GHashTable *texture_id_to_key;

  GPtrArray *atlases;

  GHashTable *shader_cache;

  GArray *autorelease_framebuffers;
  GPtrArray *render_targets;

#define GSK_NGL_NO_UNIFORMS
#define GSK_NGL_ADD_UNIFORM(pos, KEY, name)
#define GSK_NGL_DEFINE_PROGRAM(name, resource, uniforms) GskNglProgram *name;
# include "gsknglprograms.defs"
#undef GSK_NGL_NO_UNIFORMS
#undef GSK_NGL_ADD_UNIFORM
#undef GSK_NGL_DEFINE_PROGRAM

  gint64 current_frame_id;

  /* Used to reduce number of comparisons */
  guint stamps[UNIFORM_SHARED_LAST];

  guint debug : 1;
  guint in_frame : 1;
};
</STRUCT>
<FUNCTION>
<NAME>gsk_ngl_driver_from_shared_context</NAME>
<RETURNS>GskNglDriver *</RETURNS>
GdkGLContext         *context, gboolean              debug_shaders, GError              **error
</FUNCTION>
<FUNCTION>
<NAME>gsk_ngl_driver_create_command_queue</NAME>
<RETURNS>GskNglCommandQueue *</RETURNS>
GskNglDriver         *self, GdkGLContext         *context
</FUNCTION>
<FUNCTION>
<NAME>gsk_ngl_driver_get_context</NAME>
<RETURNS>GdkGLContext *</RETURNS>
GskNglDriver         *self
</FUNCTION>
<FUNCTION>
<NAME>gsk_ngl_driver_create_render_target</NAME>
<RETURNS>gboolean</RETURNS>
GskNglDriver         *self, int                   width, int                   height, int                   min_filter, int                   mag_filter, GskNglRenderTarget  **render_target
</FUNCTION>
<FUNCTION>
<NAME>gsk_ngl_driver_release_render_target</NAME>
<RETURNS>guint</RETURNS>
GskNglDriver         *self, GskNglRenderTarget   *render_target, gboolean              release_texture
</FUNCTION>
<FUNCTION>
<NAME>gsk_ngl_driver_begin_frame</NAME>
<RETURNS>void</RETURNS>
GskNglDriver         *self, GskNglCommandQueue   *command_queue
</FUNCTION>
<FUNCTION>
<NAME>gsk_ngl_driver_end_frame</NAME>
<RETURNS>void</RETURNS>
GskNglDriver         *self
</FUNCTION>
<FUNCTION>
<NAME>gsk_ngl_driver_after_frame</NAME>
<RETURNS>void</RETURNS>
GskNglDriver         *self
</FUNCTION>
<FUNCTION>
<NAME>gsk_ngl_driver_create_gdk_texture</NAME>
<RETURNS>GdkTexture *</RETURNS>
GskNglDriver         *self, guint                 texture_id
</FUNCTION>
<FUNCTION>
<NAME>gsk_ngl_driver_cache_texture</NAME>
<RETURNS>void</RETURNS>
GskNglDriver         *self, const GskTextureKey  *key, guint                 texture_id
</FUNCTION>
<FUNCTION>
<NAME>gsk_ngl_driver_load_texture</NAME>
<RETURNS>guint</RETURNS>
GskNglDriver         *self, GdkTexture           *texture, int                   min_filter, int                   mag_filter
</FUNCTION>
<FUNCTION>
<NAME>gsk_ngl_driver_create_texture</NAME>
<RETURNS>GskNglTexture *</RETURNS>
GskNglDriver         *self, float                 width, float                 height, int                   min_filter, int                   mag_filter
</FUNCTION>
<FUNCTION>
<NAME>gsk_ngl_driver_release_texture</NAME>
<RETURNS>void</RETURNS>
GskNglDriver         *self, GskNglTexture        *texture
</FUNCTION>
<FUNCTION>
<NAME>gsk_ngl_driver_release_texture_by_id</NAME>
<RETURNS>void</RETURNS>
GskNglDriver         *self, guint                 texture_id
</FUNCTION>
<FUNCTION>
<NAME>gsk_ngl_driver_mark_texture_permanent</NAME>
<RETURNS>GskNglTexture *</RETURNS>
GskNglDriver         *self, guint                 texture_id
</FUNCTION>
<FUNCTION>
<NAME>gsk_ngl_driver_add_texture_slices</NAME>
<RETURNS>void</RETURNS>
GskNglDriver         *self, GdkTexture           *texture, GskNglTextureSlice  **out_slices, guint                *out_n_slices
</FUNCTION>
<FUNCTION>
<NAME>gsk_ngl_driver_lookup_shader</NAME>
<RETURNS>GskNglProgram *</RETURNS>
GskNglDriver         *self, GskGLShader          *shader, GError              **error
</FUNCTION>
<FUNCTION>
<NAME>gsk_ngl_driver_create_atlas</NAME>
<RETURNS>GskNglTextureAtlas *</RETURNS>
GskNglDriver         *self
</FUNCTION>
<FUNCTION>
<NAME>gsk_ngl_driver_save_atlases_to_png</NAME>
<RETURNS>void</RETURNS>
GskNglDriver         *self, const char           *directory
</FUNCTION>
<FUNCTION>
<NAME>gsk_ngl_driver_get_texture_by_id</NAME>
<RETURNS>GskNglTexture *</RETURNS>
GskNglDriver *self, guint         texture_id
</FUNCTION>
<FUNCTION>
<NAME>gsk_ngl_driver_lookup_texture</NAME>
<RETURNS>guint</RETURNS>
GskNglDriver        *self, const GskTextureKey *key
</FUNCTION>
<FUNCTION>
<NAME>gsk_ngl_driver_slice_texture</NAME>
<RETURNS>void</RETURNS>
GskNglDriver        *self, GdkTexture          *texture, GskNglTextureSlice **out_slices, guint               *out_n_slices
</FUNCTION>
<MACRO>
<NAME>GSK_TYPE_GL_GLYPH_LIBRARY</NAME>
#define GSK_TYPE_GL_GLYPH_LIBRARY (gsk_ngl_glyph_library_get_type())
</MACRO>
<FUNCTION>
<NAME>sizeof</NAME>
<RETURNS>G_STATIC_ASSERT</RETURNS>
GskNglGlyphKey) == 16
</FUNCTION>
<STRUCT>
<NAME>GskNglGlyphLibrary</NAME>
struct _GskNglGlyphLibrary
{
  GskNglTextureLibrary parent_instance;
  GHashTable *hash_table;
  guint8 *surface_data;
  gsize surface_data_len;
  struct {
    GskNglGlyphKey key;
    const GskNglGlyphValue *value;
  } front[256];
};
</STRUCT>
<FUNCTION>
<NAME>gsk_ngl_glyph_library_new</NAME>
<RETURNS>GskNglGlyphLibrary *</RETURNS>
GskNglDriver            *driver
</FUNCTION>
<FUNCTION>
<NAME>gsk_ngl_glyph_library_add</NAME>
<RETURNS>gboolean</RETURNS>
GskNglGlyphLibrary      *self, GskNglGlyphKey          *key, const GskNglGlyphValue **out_value
</FUNCTION>
<FUNCTION>
<NAME>gsk_ngl_glyph_key_phase</NAME>
<RETURNS>int</RETURNS>
float value
</FUNCTION>
<FUNCTION>
<NAME>gsk_ngl_glyph_key_set_glyph_and_shift</NAME>
<RETURNS>void</RETURNS>
GskNglGlyphKey *key, PangoGlyph      glyph, float           x, float           y
</FUNCTION>
<FUNCTION>
<NAME>gsk_ngl_glyph_library_lookup_or_add</NAME>
<RETURNS>gboolean</RETURNS>
GskNglGlyphLibrary      *self, const GskNglGlyphKey    *key, const GskNglGlyphValue **out_value
</FUNCTION>
<MACRO>
<NAME>GSK_TYPE_GL_ICON_LIBRARY</NAME>
#define GSK_TYPE_GL_ICON_LIBRARY (gsk_ngl_icon_library_get_type())
</MACRO>
<FUNCTION>
<NAME>gsk_ngl_icon_library_new</NAME>
<RETURNS>GskNglIconLibrary *</RETURNS>
GskNglDriver          *driver
</FUNCTION>
<FUNCTION>
<NAME>gsk_ngl_icon_library_add</NAME>
<RETURNS>void</RETURNS>
GskNglIconLibrary     *self, GdkTexture            *key, const GskNglIconData **out_value
</FUNCTION>
<FUNCTION>
<NAME>gsk_ngl_icon_library_lookup_or_add</NAME>
<RETURNS>void</RETURNS>
GskNglIconLibrary     *self, GdkTexture            *key, const GskNglIconData **out_value
</FUNCTION>
<STRUCT>
<NAME>GskNglIconLibrary</NAME>
</STRUCT>
<MACRO>
<NAME>GSK_TYPE_GL_PROGRAM</NAME>
#define GSK_TYPE_GL_PROGRAM (gsk_ngl_program_get_type())
</MACRO>
<STRUCT>
<NAME>GskNglProgram</NAME>
struct _GskNglProgram
{
  GObject parent_instance;

  int id;
  char *name;
  GskNglDriver *driver;

  /* In reality, this is the largest uniform position
   * as returned after linking so that we can use direct
   * indexes based on location.
   */
  guint n_uniforms;

  /* Cached pointer to avoid lots of pointer chasing/lookups */
  GskNglUniformState *uniforms;
  GskNglUniformProgram *program_info;

  /* For custom programs */
  int texture_locations[4];
  int args_locations[8];
  int size_location;

  /* Static array for key->location transforms */
  int uniform_locations[32];
};
</STRUCT>
<FUNCTION>
<NAME>gsk_ngl_program_new</NAME>
<RETURNS>GskNglProgram *</RETURNS>
GskNglDriver  *driver, const char    *name, int            program_id
</FUNCTION>
<FUNCTION>
<NAME>gsk_ngl_program_add_uniform</NAME>
<RETURNS>gboolean</RETURNS>
GskNglProgram *self, const char    *name, guint          key
</FUNCTION>
<FUNCTION>
<NAME>gsk_ngl_program_uniforms_added</NAME>
<RETURNS>void</RETURNS>
GskNglProgram *self, gboolean       has_attachments
</FUNCTION>
<FUNCTION>
<NAME>gsk_ngl_program_delete</NAME>
<RETURNS>void</RETURNS>
GskNglProgram *self
</FUNCTION>
<MACRO>
<NAME>gsk_ngl_program_get_uniform_location</NAME>
#define gsk_ngl_program_get_uniform_location(s,k) ((s)->uniform_locations[(k)])
</MACRO>
<FUNCTION>
<NAME>gsk_ngl_program_set_uniform1fv</NAME>
<RETURNS>void</RETURNS>
GskNglProgram *self, guint          key, guint          stamp, guint          count, const float   *values
</FUNCTION>
<FUNCTION>
<NAME>gsk_ngl_program_set_uniform2fv</NAME>
<RETURNS>void</RETURNS>
GskNglProgram *self, guint          key, guint          stamp, guint          count, const float   *values
</FUNCTION>
<FUNCTION>
<NAME>gsk_ngl_program_set_uniform4fv</NAME>
<RETURNS>void</RETURNS>
GskNglProgram *self, guint          key, guint          stamp, guint          count, const float   *values
</FUNCTION>
<FUNCTION>
<NAME>gsk_ngl_program_set_uniform_rounded_rect</NAME>
<RETURNS>void</RETURNS>
GskNglProgram        *self, guint                 key, guint                 stamp, const GskRoundedRect *rounded_rect
</FUNCTION>
<FUNCTION>
<NAME>gsk_ngl_program_set_uniform1i</NAME>
<RETURNS>void</RETURNS>
GskNglProgram *self, guint          key, guint          stamp, int            value0
</FUNCTION>
<FUNCTION>
<NAME>gsk_ngl_program_set_uniform2i</NAME>
<RETURNS>void</RETURNS>
GskNglProgram *self, guint          key, guint          stamp, int            value0, int            value1
</FUNCTION>
<FUNCTION>
<NAME>gsk_ngl_program_set_uniform3i</NAME>
<RETURNS>void</RETURNS>
GskNglProgram *self, guint          key, guint          stamp, int            value0, int            value1, int            value2
</FUNCTION>
<FUNCTION>
<NAME>gsk_ngl_program_set_uniform4i</NAME>
<RETURNS>void</RETURNS>
GskNglProgram *self, guint          key, guint          stamp, int            value0, int            value1, int            value2, int            value3
</FUNCTION>
<FUNCTION>
<NAME>gsk_ngl_program_set_uniform1f</NAME>
<RETURNS>void</RETURNS>
GskNglProgram *self, guint          key, guint          stamp, float          value0
</FUNCTION>
<FUNCTION>
<NAME>gsk_ngl_program_set_uniform2f</NAME>
<RETURNS>void</RETURNS>
GskNglProgram *self, guint          key, guint          stamp, float          value0, float          value1
</FUNCTION>
<FUNCTION>
<NAME>gsk_ngl_program_set_uniform3f</NAME>
<RETURNS>void</RETURNS>
GskNglProgram *self, guint          key, guint          stamp, float          value0, float          value1, float          value2
</FUNCTION>
<FUNCTION>
<NAME>gsk_ngl_program_set_uniform4f</NAME>
<RETURNS>void</RETURNS>
GskNglProgram *self, guint          key, guint          stamp, float          value0, float          value1, float          value2, float          value3
</FUNCTION>
<FUNCTION>
<NAME>gsk_ngl_program_set_uniform_color</NAME>
<RETURNS>void</RETURNS>
GskNglProgram *self, guint          key, guint          stamp, const GdkRGBA *color
</FUNCTION>
<FUNCTION>
<NAME>gsk_ngl_program_set_uniform_texture</NAME>
<RETURNS>void</RETURNS>
GskNglProgram *self, guint          key, guint          stamp, GLenum         texture_target, GLenum         texture_slot, guint          texture_id
</FUNCTION>
<FUNCTION>
<NAME>gsk_ngl_program_set_uniform_matrix</NAME>
<RETURNS>void</RETURNS>
GskNglProgram           *self, guint                    key, guint                    stamp, const graphene_matrix_t *matrix
</FUNCTION>
<MACRO>
<NAME>GSK_TYPE_NGL_RENDERER</NAME>
#define GSK_TYPE_NGL_RENDERER (gsk_ngl_renderer_get_type())
</MACRO>
<MACRO>
<NAME>GSK_NGL_RENDERER</NAME>
#define GSK_NGL_RENDERER(obj)                    (G_TYPE_CHECK_INSTANCE_CAST ((obj), GSK_TYPE_NGL_RENDERER, GskNglRenderer))
</MACRO>
<MACRO>
<NAME>GSK_IS_NGL_RENDERER</NAME>
#define GSK_IS_NGL_RENDERER(obj)                 (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GSK_TYPE_NGL_RENDERER))
</MACRO>
<MACRO>
<NAME>GSK_NGL_RENDERER_CLASS</NAME>
#define GSK_NGL_RENDERER_CLASS(klass)            (G_TYPE_CHECK_CLASS_CAST ((klass), GSK_TYPE_NGL_RENDERER, GskNglRendererClass))
</MACRO>
<MACRO>
<NAME>GSK_IS_NGL_RENDERER_CLASS</NAME>
#define GSK_IS_NGL_RENDERER_CLASS(klass)         (G_TYPE_CHECK_CLASS_TYPE ((klass), GSK_TYPE_NGL_RENDERER))
</MACRO>
<MACRO>
<NAME>GSK_NGL_RENDERER_GET_CLASS</NAME>
#define GSK_NGL_RENDERER_GET_CLASS(obj)          (G_TYPE_INSTANCE_GET_CLASS ((obj), GSK_TYPE_NGL_RENDERER, GskNglRendererClass))
</MACRO>
<FUNCTION>
<NAME>gsk_ngl_renderer_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gsk_ngl_renderer_new</NAME>
<RETURNS>GskRenderer *</RETURNS>
void
</FUNCTION>
<STRUCT>
<NAME>GskNglRenderer</NAME>
</STRUCT>
<STRUCT>
<NAME>GskNglRendererClass</NAME>
</STRUCT>
<FUNCTION>
<NAME>gsk_ngl_renderer_try_compile_gl_shader</NAME>
<RETURNS>gboolean</RETURNS>
GskNglRenderer  *renderer, GskGLShader     *shader, GError         **error
</FUNCTION>
<FUNCTION>
<NAME>gsk_ngl_render_job_new</NAME>
<RETURNS>GskNglRenderJob *</RETURNS>
GskNglDriver          *driver, const graphene_rect_t *viewport, float                  scale_factor, const cairo_region_t  *region, guint                  framebuffer
</FUNCTION>
<FUNCTION>
<NAME>gsk_ngl_render_job_free</NAME>
<RETURNS>void</RETURNS>
GskNglRenderJob       *job
</FUNCTION>
<FUNCTION>
<NAME>gsk_ngl_render_job_render</NAME>
<RETURNS>void</RETURNS>
GskNglRenderJob       *job, GskRenderNode         *root
</FUNCTION>
<FUNCTION>
<NAME>gsk_ngl_render_job_render_flipped</NAME>
<RETURNS>void</RETURNS>
GskNglRenderJob       *job, GskRenderNode         *root
</FUNCTION>
<FUNCTION>
<NAME>gsk_ngl_render_job_set_debug_fallback</NAME>
<RETURNS>void</RETURNS>
GskNglRenderJob       *job, gboolean               debug_fallback
</FUNCTION>
<MACRO>
<NAME>GSK_TYPE_GL_SHADOW_LIBRARY</NAME>
#define GSK_TYPE_GL_SHADOW_LIBRARY (gsk_ngl_shadow_library_get_type())
</MACRO>
<FUNCTION>
<NAME>gsk_ngl_shadow_library_new</NAME>
<RETURNS>GskNglShadowLibrary *</RETURNS>
GskNglDriver         *driver
</FUNCTION>
<FUNCTION>
<NAME>gsk_ngl_shadow_library_begin_frame</NAME>
<RETURNS>void</RETURNS>
GskNglShadowLibrary  *self
</FUNCTION>
<FUNCTION>
<NAME>gsk_ngl_shadow_library_lookup</NAME>
<RETURNS>guint</RETURNS>
GskNglShadowLibrary  *self, const GskRoundedRect *outline, float                 blur_radius
</FUNCTION>
<FUNCTION>
<NAME>gsk_ngl_shadow_library_insert</NAME>
<RETURNS>void</RETURNS>
GskNglShadowLibrary  *self, const GskRoundedRect *outline, float                 blur_radius, guint                 texture_id
</FUNCTION>
<STRUCT>
<NAME>GskNglShadowLibrary</NAME>
</STRUCT>
<MACRO>
<NAME>GSK_TYPE_GL_TEXTURE_LIBRARY</NAME>
#define GSK_TYPE_GL_TEXTURE_LIBRARY            (gsk_ngl_texture_library_get_type ())
</MACRO>
<MACRO>
<NAME>GSK_NGL_TEXTURE_LIBRARY</NAME>
#define GSK_NGL_TEXTURE_LIBRARY(obj)            (G_TYPE_CHECK_INSTANCE_CAST ((obj), GSK_TYPE_GL_TEXTURE_LIBRARY, GskNglTextureLibrary))
</MACRO>
<MACRO>
<NAME>GSK_IS_NGL_TEXTURE_LIBRARY</NAME>
#define GSK_IS_NGL_TEXTURE_LIBRARY(obj)         (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GSK_TYPE_GL_TEXTURE_LIBRARY))
</MACRO>
<MACRO>
<NAME>GSK_NGL_TEXTURE_LIBRARY_CLASS</NAME>
#define GSK_NGL_TEXTURE_LIBRARY_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST ((klass), GSK_TYPE_GL_TEXTURE_LIBRARY, GskNglTextureLibraryClass))
</MACRO>
<MACRO>
<NAME>GSK_IS_NGL_TEXTURE_LIBRARY_CLASS</NAME>
#define GSK_IS_NGL_TEXTURE_LIBRARY_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GSK_TYPE_GL_TEXTURE_LIBRARY))
</MACRO>
<MACRO>
<NAME>GSK_NGL_TEXTURE_LIBRARY_GET_CLASS</NAME>
#define GSK_NGL_TEXTURE_LIBRARY_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS ((obj), GSK_TYPE_GL_TEXTURE_LIBRARY, GskNglTextureLibraryClass))
</MACRO>
<STRUCT>
<NAME>stbrp_context</NAME>
  struct stbrp_context context;
  struct stbrp_node *nodes;

  int width;
  int height;

  guint texture_id;

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

  void *user_data;
} GskNglTextureAtlas;
</STRUCT>
<USER_FUNCTION>
<NAME>begin_frame</NAME>
<RETURNS>void</RETURNS>
GskNglTextureLibrary *library
</USER_FUNCTION>
<USER_FUNCTION>
<NAME>end_frame</NAME>
<RETURNS>void</RETURNS>
GskNglTextureLibrary *library
</USER_FUNCTION>
<FUNCTION>
<NAME>gsk_ngl_texture_library_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gsk_ngl_texture_library_set_funcs</NAME>
<RETURNS>void</RETURNS>
GskNglTextureLibrary *self, GHashFunc             hash_func, GEqualFunc            equal_func, GDestroyNotify        key_destroy, GDestroyNotify        value_destroy
</FUNCTION>
<FUNCTION>
<NAME>gsk_ngl_texture_library_begin_frame</NAME>
<RETURNS>void</RETURNS>
GskNglTextureLibrary *self
</FUNCTION>
<FUNCTION>
<NAME>gsk_ngl_texture_library_end_frame</NAME>
<RETURNS>void</RETURNS>
GskNglTextureLibrary *self
</FUNCTION>
<FUNCTION>
<NAME>gsk_ngl_texture_library_pack</NAME>
<RETURNS>gpointer</RETURNS>
GskNglTextureLibrary *self, gpointer              key, gsize                 valuelen, guint                 width, guint                 height, int                   padding, guint                *out_packed_x, guint                *out_packed_y
</FUNCTION>
<FUNCTION>
<NAME>gsk_ngl_texture_atlas_mark_unused</NAME>
<RETURNS>void</RETURNS>
GskNglTextureAtlas *self, int                 n_pixels
</FUNCTION>
<FUNCTION>
<NAME>gsk_ngl_texture_atlas_mark_used</NAME>
<RETURNS>void</RETURNS>
GskNglTextureAtlas *self, int                 n_pixels
</FUNCTION>
<FUNCTION>
<NAME>gsk_ngl_texture_library_lookup</NAME>
<RETURNS>gboolean</RETURNS>
GskNglTextureLibrary     *self, gconstpointer             key, GskNglTextureAtlasEntry **out_entry
</FUNCTION>
<FUNCTION>
<NAME>GSK_NGL_TEXTURE_ATLAS_ENTRY_TEXTURE</NAME>
<RETURNS>guint</RETURNS>
gconstpointer d
</FUNCTION>
<FUNCTION>
<NAME>gsk_ngl_texture_atlas_get_unused_ratio</NAME>
<RETURNS>double</RETURNS>
const GskNglTextureAtlas *self
</FUNCTION>
<FUNCTION>
<NAME>gsk_ngl_texture_library_can_cache</NAME>
<RETURNS>gboolean</RETURNS>
GskNglTextureLibrary *self, int                   width, int                   height
</FUNCTION>
<STRUCT>
<NAME>GskNglTextureSlice</NAME>
struct _GskNglTextureSlice
{
  cairo_rectangle_int_t rect;
  guint texture_id;
};
</STRUCT>
<STRUCT>
<NAME>GskNglTextureNineSlice</NAME>
struct _GskNglTextureNineSlice
{
  cairo_rectangle_int_t rect;
  struct {
    float x;
    float y;
    float x2;
    float y2;
  } area;
};
</STRUCT>
<STRUCT>
<NAME>GskNglTexture</NAME>
struct _GskNglTexture
{
  /* Used to insert into queue */
  GList link;

  /* Identifier of the frame that created it */
  gint64 last_used_in_frame;

  /* Backpointer to texture (can be cleared asynchronously) */
  GdkTexture *user;

  /* Only used by sliced textures */
  GskNglTextureSlice *slices;
  guint n_slices;

  /* Only used by nine-slice textures */
  GskNglTextureNineSlice *nine_slice;

  /* The actual GL texture identifier in some shared context */
  guint texture_id;

  int width;
  int height;
  int min_filter;
  int mag_filter;

  /* Set when used by an atlas so we don't drop the texture */
  guint              permanent : 1;
};
</STRUCT>
<FUNCTION>
<NAME>gsk_ngl_texture_pool_init</NAME>
<RETURNS>void</RETURNS>
GskNglTexturePool    *self
</FUNCTION>
<FUNCTION>
<NAME>gsk_ngl_texture_pool_clear</NAME>
<RETURNS>void</RETURNS>
GskNglTexturePool    *self
</FUNCTION>
<FUNCTION>
<NAME>gsk_ngl_texture_pool_get</NAME>
<RETURNS>GskNglTexture *</RETURNS>
GskNglTexturePool    *self, int                   width, int                   height, int                   min_filter, int                   mag_filter
</FUNCTION>
<FUNCTION>
<NAME>gsk_ngl_texture_pool_put</NAME>
<RETURNS>void</RETURNS>
GskNglTexturePool    *self, GskNglTexture        *texture
</FUNCTION>
<FUNCTION>
<NAME>gsk_ngl_texture_new</NAME>
<RETURNS>GskNglTexture *</RETURNS>
guint                 texture_id, int                   width, int                   height, int                   min_filter, int                   mag_filter, gint64                frame_id
</FUNCTION>
<FUNCTION>
<NAME>gsk_ngl_texture_get_nine_slice</NAME>
<RETURNS>const GskNglTextureNineSlice *</RETURNS>
GskNglTexture        *texture, const GskRoundedRect *outline, float                 extra_pixels
</FUNCTION>
<FUNCTION>
<NAME>gsk_ngl_texture_free</NAME>
<RETURNS>void</RETURNS>
GskNglTexture        *texture
</FUNCTION>
<MACRO>
<NAME>GSK_NGL_N_VERTICES</NAME>
#define GSK_NGL_N_VERTICES 6
</MACRO>
<STRUCT>
<NAME>GskNglDrawVertex</NAME>
struct _GskNglDrawVertex
{
  float position[2];
  float uv[2];
};
</STRUCT>
<STRUCT>
<NAME>GskNglAttachmentState</NAME>
</STRUCT>
<STRUCT>
<NAME>GskNglBuffer</NAME>
</STRUCT>
<STRUCT>
<NAME>GskNglCommandQueue</NAME>
</STRUCT>
<STRUCT>
<NAME>GskNglCompiler</NAME>
</STRUCT>
<STRUCT>
<NAME>GskNglDriver</NAME>
</STRUCT>
<STRUCT>
<NAME>GskNglGlyphLibrary</NAME>
</STRUCT>
<STRUCT>
<NAME>GskNglIconLibrary</NAME>
</STRUCT>
<STRUCT>
<NAME>GskNglProgram</NAME>
</STRUCT>
<STRUCT>
<NAME>GskNglRenderJob</NAME>
</STRUCT>
<STRUCT>
<NAME>GskNglRenderTarget</NAME>
</STRUCT>
<STRUCT>
<NAME>GskNglShadowLibrary</NAME>
</STRUCT>
<STRUCT>
<NAME>GskNglTexture</NAME>
</STRUCT>
<STRUCT>
<NAME>GskNglTextureAtlas</NAME>
</STRUCT>
<STRUCT>
<NAME>GskNglTextureLibrary</NAME>
</STRUCT>
<STRUCT>
<NAME>GskNglTextureNineSlice</NAME>
</STRUCT>
<STRUCT>
<NAME>GskNglTextureSlice</NAME>
</STRUCT>
<STRUCT>
<NAME>GskNglUniformInfo</NAME>
</STRUCT>
<STRUCT>
<NAME>GskNglUniformProgram</NAME>
</STRUCT>
<STRUCT>
<NAME>GskNglUniformState</NAME>
</STRUCT>
<STRUCT>
<NAME>GskNglUniformInfo</NAME>
typedef struct { float v0; } Uniform1f;
typedef struct { float v0; float v1; } Uniform2f;
typedef struct { float v0; float v1; float v2; } Uniform3f;
typedef struct { float v0; float v1; float v2; float v3; } Uniform4f;

typedef struct { int v0; } Uniform1i;
typedef struct { int v0; int v1; } Uniform2i;
typedef struct { int v0; int v1; int v2; } Uniform3i;
typedef struct { int v0; int v1; int v2; int v3; } Uniform4i;

typedef struct { guint v0; } Uniform1ui;

#define GSK_NGL_UNIFORM_ARRAY_BITS  5
#define GSK_NGL_UNIFORM_FORMAT_BITS 5
#define GSK_NGL_UNIFORM_OFFSET_BITS 21

typedef struct _GskNglUniformInfo
{
  guint initial     : 1;
  guint format      : GSK_NGL_UNIFORM_FORMAT_BITS;
  guint array_count : GSK_NGL_UNIFORM_ARRAY_BITS;
  guint offset      : GSK_NGL_UNIFORM_OFFSET_BITS;
} GskNglUniformInfo;
</STRUCT>
<FUNCTION>
<NAME>sizeof</NAME>
<RETURNS>G_STATIC_ASSERT</RETURNS>
GskNglUniformInfo) == 4
</FUNCTION>
<USER_FUNCTION>
<NAME>GskNglUniformStateCallback</NAME>
<RETURNS>void</RETURNS>
const GskNglUniformInfo *info, guint                    location, gpointer                 user_data
</USER_FUNCTION>
<ENUM>
<NAME>GskNglUniformFormat</NAME>
typedef enum _GskNglUniformKind
{
  GSK_NGL_UNIFORM_FORMAT_1F = 1,
  GSK_NGL_UNIFORM_FORMAT_2F,
  GSK_NGL_UNIFORM_FORMAT_3F,
  GSK_NGL_UNIFORM_FORMAT_4F,

  GSK_NGL_UNIFORM_FORMAT_1FV,
  GSK_NGL_UNIFORM_FORMAT_2FV,
  GSK_NGL_UNIFORM_FORMAT_3FV,
  GSK_NGL_UNIFORM_FORMAT_4FV,

  GSK_NGL_UNIFORM_FORMAT_1I,
  GSK_NGL_UNIFORM_FORMAT_2I,
  GSK_NGL_UNIFORM_FORMAT_3I,
  GSK_NGL_UNIFORM_FORMAT_4I,

  GSK_NGL_UNIFORM_FORMAT_1UI,

  GSK_NGL_UNIFORM_FORMAT_TEXTURE,

  GSK_NGL_UNIFORM_FORMAT_MATRIX,
  GSK_NGL_UNIFORM_FORMAT_ROUNDED_RECT,
  GSK_NGL_UNIFORM_FORMAT_COLOR,

  GSK_NGL_UNIFORM_FORMAT_LAST
} GskNglUniformFormat;
</ENUM>
<FUNCTION>
<NAME>gsk_ngl_uniform_state_new</NAME>
<RETURNS>GskNglUniformState *</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>gsk_ngl_uniform_state_ref</NAME>
<RETURNS>GskNglUniformState *</RETURNS>
GskNglUniformState        *state
</FUNCTION>
<FUNCTION>
<NAME>gsk_ngl_uniform_state_unref</NAME>
<RETURNS>void</RETURNS>
GskNglUniformState        *state
</FUNCTION>
<FUNCTION>
<NAME>gsk_ngl_uniform_state_get_program</NAME>
<RETURNS>GskNglUniformProgram *</RETURNS>
GskNglUniformState        *state, guint                      program, guint                      n_uniforms
</FUNCTION>
<FUNCTION>
<NAME>gsk_ngl_uniform_state_end_frame</NAME>
<RETURNS>void</RETURNS>
GskNglUniformState        *state
</FUNCTION>
<FUNCTION>
<NAME>gsk_ngl_uniform_format_size</NAME>
<RETURNS>gsize</RETURNS>
GskNglUniformFormat        format
</FUNCTION>
<FUNCTION>
<NAME>gsk_ngl_uniform_state_init_value</NAME>
<RETURNS>gpointer</RETURNS>
GskNglUniformState        *state, GskNglUniformProgram      *program, GskNglUniformFormat        format, guint                      array_count, guint                      location, GskNglUniformInfoElement **infoptr
</FUNCTION>
<MACRO>
<NAME>GSK_NGL_UNIFORM_VALUE</NAME>
#define GSK_NGL_UNIFORM_VALUE(base, offset) ((gpointer)((base) + ((offset) * 4)))
</MACRO>
<MACRO>
<NAME>gsk_ngl_uniform_state_get_uniform_data</NAME>
#define gsk_ngl_uniform_state_get_uniform_data(state,offset) GSK_NGL_UNIFORM_VALUE((state)->values_buf, offset)
</MACRO>
<MACRO>
<NAME>gsk_ngl_uniform_state_snapshot</NAME>
#define gsk_ngl_uniform_state_snapshot(state, program_info, callback, user_data) \
  G_STMT_START {                                                                 \
    for (guint z = 0; z < program_info->n_sparse; z++)                           \
      {                                                                          \
        guint location = program_info->sparse[z];                                \
        GskNglUniformInfoElement *info = &program_info->uniforms[location];      \
                                                                                 \
        g_assert (location < GL_MAX_UNIFORM_LOCATIONS);                          \
        g_assert (location < program_info->n_uniforms);                          \
                                                                                 \
        if (info->info.format > 0)                                               \
          callback (&info->info, location, user_data);                           \
      }                                                                          \
  } G_STMT_END
</MACRO>
<FUNCTION>
<NAME>gsk_ngl_uniform_state_get_value</NAME>
<RETURNS>gpointer</RETURNS>
GskNglUniformState        *state, GskNglUniformProgram      *program, GskNglUniformFormat        format, guint                      array_count, guint                      location, guint                      stamp, GskNglUniformInfoElement **infoptr
</FUNCTION>
<FUNCTION>
<NAME>gsk_ngl_uniform_state_align</NAME>
<RETURNS>guint</RETURNS>
guint current_pos, guint size
</FUNCTION>
<FUNCTION>
<NAME>gsk_ngl_uniform_state_realloc</NAME>
<RETURNS>gpointer</RETURNS>
GskNglUniformState *state, guint               size, guint              *offset
</FUNCTION>
<MACRO>
<NAME>GSK_NGL_UNIFORM_STATE_REPLACE</NAME>
#define GSK_NGL_UNIFORM_STATE_REPLACE(info, u, type, count)                                \
  G_STMT_START {                                                                           \
    if ((info)->info.initial && count == (info)->info.array_count)                         \
      {                                                                                    \
        u = GSK_NGL_UNIFORM_VALUE (state->values_buf, (info)->info.offset);                \
      }                                                                                    \
    else                                                                                   \
      {                                                                                    \
        guint offset;                                                                      \
        u = gsk_ngl_uniform_state_realloc (state, sizeof(type) * MAX (1, count), &offset); \
        g_assert (offset < (1 << GSK_NGL_UNIFORM_OFFSET_BITS));                            \
        (info)->info.offset = offset;                                                      \
        /* We might have increased array length */                                         \
        (info)->info.array_count = count;                                                  \
      }                                                                                    \
  } G_STMT_END
</MACRO>
<FUNCTION>
<NAME>gsk_ngl_uniform_info_changed</NAME>
<RETURNS>void</RETURNS>
GskNglUniformInfoElement *info, guint                     location, guint                     stamp
</FUNCTION>
<FUNCTION>
<NAME>gsk_ngl_uniform_state_set1f</NAME>
<RETURNS>void</RETURNS>
GskNglUniformState   *state, GskNglUniformProgram *program, guint                 location, guint                 stamp, float                 value0
</FUNCTION>
<FUNCTION>
<NAME>gsk_ngl_uniform_state_set2f</NAME>
<RETURNS>void</RETURNS>
GskNglUniformState   *state, GskNglUniformProgram *program, guint                 location, guint                 stamp, float                 value0, float                 value1
</FUNCTION>
<FUNCTION>
<NAME>gsk_ngl_uniform_state_set3f</NAME>
<RETURNS>void</RETURNS>
GskNglUniformState   *state, GskNglUniformProgram *program, guint                 location, guint                 stamp, float                 value0, float                 value1, float                 value2
</FUNCTION>
<FUNCTION>
<NAME>gsk_ngl_uniform_state_set4f</NAME>
<RETURNS>void</RETURNS>
GskNglUniformState   *state, GskNglUniformProgram *program, guint                 location, guint                 stamp, float                 value0, float                 value1, float                 value2, float                 value3
</FUNCTION>
<FUNCTION>
<NAME>gsk_ngl_uniform_state_set1ui</NAME>
<RETURNS>void</RETURNS>
GskNglUniformState   *state, GskNglUniformProgram *program, guint                 location, guint                 stamp, guint                 value0
</FUNCTION>
<FUNCTION>
<NAME>gsk_ngl_uniform_state_set1i</NAME>
<RETURNS>void</RETURNS>
GskNglUniformState   *state, GskNglUniformProgram *program, guint                 location, guint                 stamp, int                   value0
</FUNCTION>
<FUNCTION>
<NAME>gsk_ngl_uniform_state_set2i</NAME>
<RETURNS>void</RETURNS>
GskNglUniformState   *state, GskNglUniformProgram *program, guint                 location, guint                 stamp, int                   value0, int                   value1
</FUNCTION>
<FUNCTION>
<NAME>gsk_ngl_uniform_state_set3i</NAME>
<RETURNS>void</RETURNS>
GskNglUniformState   *state, GskNglUniformProgram *program, guint                 location, guint                 stamp, int                   value0, int                   value1, int                   value2
</FUNCTION>
<FUNCTION>
<NAME>gsk_ngl_uniform_state_set4i</NAME>
<RETURNS>void</RETURNS>
GskNglUniformState   *state, GskNglUniformProgram *program, guint                 location, guint                 stamp, int                   value0, int                   value1, int                   value2, int                   value3
</FUNCTION>
<FUNCTION>
<NAME>gsk_ngl_uniform_state_set_rounded_rect</NAME>
<RETURNS>void</RETURNS>
GskNglUniformState   *state, GskNglUniformProgram *program, guint                 location, guint                 stamp, const GskRoundedRect *rounded_rect
</FUNCTION>
<FUNCTION>
<NAME>gsk_ngl_uniform_state_set_matrix</NAME>
<RETURNS>void</RETURNS>
GskNglUniformState      *state, GskNglUniformProgram    *program, guint                    location, guint                    stamp, const graphene_matrix_t *matrix
</FUNCTION>
<FUNCTION>
<NAME>gsk_ngl_uniform_state_set_texture</NAME>
<RETURNS>void</RETURNS>
GskNglUniformState   *state, GskNglUniformProgram *program, guint                 location, guint                 stamp, guint                 texture_slot
</FUNCTION>
<FUNCTION>
<NAME>gsk_ngl_uniform_state_set_color</NAME>
<RETURNS>void</RETURNS>
GskNglUniformState   *state, GskNglUniformProgram *program, guint                 location, guint                 stamp, const GdkRGBA        *color
</FUNCTION>
<FUNCTION>
<NAME>gsk_ngl_uniform_state_set1fv</NAME>
<RETURNS>void</RETURNS>
GskNglUniformState   *state, GskNglUniformProgram *program, guint                 location, guint                 stamp, guint                 count, const float          *value
</FUNCTION>
<FUNCTION>
<NAME>gsk_ngl_uniform_state_set2fv</NAME>
<RETURNS>void</RETURNS>
GskNglUniformState   *state, GskNglUniformProgram *program, guint                 location, guint                 stamp, guint                 count, const float          *value
</FUNCTION>
<FUNCTION>
<NAME>gsk_ngl_uniform_state_set3fv</NAME>
<RETURNS>void</RETURNS>
GskNglUniformState   *state, GskNglUniformProgram *program, guint                 location, guint                 stamp, guint                 count, const float          *value
</FUNCTION>
<FUNCTION>
<NAME>gsk_ngl_uniform_state_set4fv</NAME>
<RETURNS>void</RETURNS>
GskNglUniformState   *state, GskNglUniformProgram *program, guint                 location, guint                 stamp, guint                 count, const float          *value
</FUNCTION>
<MACRO>
<NAME>DEFINE_INLINE_ARRAY</NAME>
#define DEFINE_INLINE_ARRAY(Type, prefix, ElementType)              \
  typedef struct _##Type {                                          \
    gsize len;                                                      \
    gsize allocated;                                                \
    ElementType *items;                                             \
  } Type;                                                           \
                                                                    \
  static inline void                                                \
  prefix##_init (Type  *ar,                                         \
                 gsize  initial_size)                               \
  {                                                                 \
    ar->len = 0;                                                    \
    ar->allocated = initial_size ? initial_size : 16;               \
    ar->items = g_new0 (ElementType, ar->allocated);                \
  }                                                                 \
                                                                    \
  static inline void                                                \
  prefix##_clear (Type *ar)                                         \
  {                                                                 \
    ar->len = 0;                                                    \
    ar->allocated = 0;                                              \
    g_clear_pointer (&ar->items, g_free);                           \
  }                                                                 \
                                                                    \
  static inline ElementType *                                       \
  prefix##_head (Type *ar)                                          \
  {                                                                 \
    return &ar->items[0];                                           \
  }                                                                 \
                                                                    \
  static inline ElementType *                                       \
  prefix##_tail (Type *ar)                                          \
  {                                                                 \
    return &ar->items[ar->len-1];                                   \
  }                                                                 \
                                                                    \
  static inline ElementType *                                       \
  prefix##_append (Type *ar)                                        \
  {                                                                 \
    if G_UNLIKELY (ar->len == ar->allocated)                        \
      {                                                             \
        ar->allocated *= 2;                                         \
        ar->items = g_renew (ElementType, ar->items, ar->allocated);\
      }                                                             \
                                                                    \
    ar->len++;                                                      \
                                                                    \
    return prefix##_tail (ar);                                      \
  }                                                                 \
                                                                    \
  static inline ElementType *                                       \
  prefix##_append_n (Type  *ar,                                     \
                     gsize  n)                                      \
  {                                                                 \
    if G_UNLIKELY ((ar->len + n) > ar->allocated)                   \
      {                                                             \
        while ((ar->len + n) > ar->allocated)                       \
          ar->allocated *= 2;                                       \
        ar->items = g_renew (ElementType, ar->items, ar->allocated);\
      }                                                             \
                                                                    \
    ar->len += n;                                                   \
                                                                    \
    return &ar->items[ar->len-n];                                   \
  }                                                                 \
                                                                    \
  static inline gsize                                               \
  prefix##_index_of (Type              *ar,                         \
                     const ElementType *element)                    \
  {                                                                 \
    return element - &ar->items[0];                                 \
  }
</MACRO>
<MACRO>
<NAME>DEBUG_NINE_SLICE</NAME>
# define DEBUG_NINE_SLICE
</MACRO>
<FUNCTION>
<NAME>nine_slice_rounded_rect</NAME>
<RETURNS>void</RETURNS>
GskNglTextureNineSlice *slices, const GskRoundedRect   *rect
</FUNCTION>
<FUNCTION>
<NAME>nine_slice_to_texture_coords</NAME>
<RETURNS>void</RETURNS>
GskNglTextureNineSlice *slices, int                     texture_width, int                     texture_height
</FUNCTION>
<FUNCTION>
<NAME>nine_slice_grow</NAME>
<RETURNS>void</RETURNS>
GskNglTextureNineSlice *slices, int                     amount
</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>
<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>
