| Top |  |
 |
 |
 |
Functions
Description
A GskGLShader is a snippet of GLSL that is meant to run in the fragment shader of the rendering pipeline. A fragment shader gets the coordinates being rendered as input and produces the pixel values for that particular pixel. Additionally, the shader can declare a set of other input arguments, called uniforms (as they are uniform over all the calls to your shader in each instance of use). A shader can also receive up to 4 textures that it can use as input when producing the pixel data.
GskGLShader is usually used with gtk_snapshot_push_gl_shader()
to produce a GskGLShaderNode in the rendering hierarchy, and then
its input textures are constructed by rendering the child nodes to
textures before rendering the shader node itself. (You can pass
texture nodes as children if you want to directly use a texture
as input).
The actual shader code is GLSL code that gets combined with some other code into the fragment shader. Since the exact capabilities of the GPU driver differs between different OpenGL drivers and hardware, GTK adds some defines that you can use to ensure your GLSL code runs on as many drivers as it can.
If the OpenGL driver is GLES, then the shader language version is set to 100, and GSK_GLES will be defined in the shader.
Otherwise, if the OpenGL driver does not support the 3.2 core profile, then the shader will run with language version 110 for GL2 and 130 for GL3, and GSK_LEGACY will be defined in the shader.
If the OpenGL driver supports the 3.2 code profile, it will be used, the shader language version is set to 150, and GSK_GL3 will be defined in the shader.
The main function the shader must implement is:
1 2 3 4 |
void mainImage(out vec4 fragColor, in vec2 fragCoord, in vec2 resolution, in vec2 uv) |
Where the input fragCoord
is the coordinate of the pixel we're
currently rendering, relative to the boundary rectangle that was
specified in the GskGLShaderNode, and resolution
is the width and
height of that rectangle. This is in the typical GTK coordinate
system with the origin in the top left. uv
contains the u and v
coordinates that can be used to index a texture at the
corresponding point. These coordinates are in the [0..1]x[0..1]
region, with 0, 0 being in the lower left corder (which is typical
for OpenGL).
The output fragColor
should be a RGBA color (with
premultiplied alpha) that will be used as the output for the
specified pixel location. Note that this output will be
automatically clipped to the clip region of the glshader node.
In addition to the function arguments the shader can define up to 4 uniforms for textures which must be called u_textureN (i.e. u_texture1 to u_texture4) as well as any custom uniforms you want of types int, uint, bool, float, vec2, vec3 or vec4.
All textures sources contain premultiplied alpha colors, but if some
there are outer sources of colors there is a gsk_premultiply() helper
to compute premultiplication when needed.
Note that GTK parses the uniform declarations, so each uniform has to be on a line by itself with no other code, like so:
1 2 3 4 |
uniform float u_time; uniform vec3 u_color; uniform sampler2D u_texture1; uniform sampler2D u_texture2; |
GTK uses the the "gsk" namespace in the symbols it uses in the shader, so your code should not use any symbols with the prefix gsk or GSK. There are some helper functions declared that you can use:
1 |
vec4 GskTexture(sampler2D sampler, vec2 texCoords); |
This samples a texture (e.g. u_texture1) at the specified coordinates, and containes some helper ifdefs to ensure that it works on all OpenGL versions.
You can compile the shader yourself using gsk_gl_shader_compile(),
otherwise the GSK renderer will do it when it handling the glshader
node. If errors occurs, the returned error
will include the glsl
sources, so you can see what GSK was passing to the compiler. You
can also set GSK_DEBUG=shaders in the environment to see the sources
and other relevant information about all shaders that GSK is handling.
An example shader
1 2 3 4 5 6 7 8 9 10 11 12 13 |
uniform float position; uniform sampler2D u_texture1; uniform sampler2D u_texture2; void mainImage(out vec4 fragColor, in vec2 fragCoord, in vec2 resolution, in vec2 uv) { vec4 source1 = GskTexture(u_texture1, uv); vec4 source2 = GskTexture(u_texture2, uv); fragColor = position * source1 + (1.0 - position) * source2; } |
Functions
gsk_gl_shader_new_from_bytes ()
GskGLShader *
gsk_gl_shader_new_from_bytes (GBytes *sourcecode);
Creates a GskGLShader that will render pixels using the specified code.
gsk_gl_shader_new_from_resource ()
GskGLShader *
gsk_gl_shader_new_from_resource (const char *resource_path);
Creates a GskGLShader that will render pixels using the specified code.
gsk_gl_shader_compile ()
gboolean gsk_gl_shader_compile (GskGLShader *shader,GskRenderer *renderer,GError **error);
Tries to compile the shader
for the given renderer
, and reports
FALSE with an error if there is a problem. You should use this
function before relying on the shader for rendering and use a
fallback with a simpler shader or without shaders if it fails.
Note that this will modify the rendering state (for example change the current GL context) and requires the renderer to be set up. This means that the widget has to be realized. Commonly you want to call this from the realize signal of a widget, or during widget snapshot.
gsk_gl_shader_get_source ()
GBytes *
gsk_gl_shader_get_source (GskGLShader *shader);
Gets the GLSL sourcecode being used to render this shader.
gsk_gl_shader_get_n_textures ()
int
gsk_gl_shader_get_n_textures (GskGLShader *shader);
Returns the number of textures that the shader requires.
This can be used to check that the a passed shader works in your usecase. It is determined by looking at the highest u_textureN value that the shader defines.
gsk_gl_shader_get_n_uniforms ()
int
gsk_gl_shader_get_n_uniforms (GskGLShader *shader);
Get the number of declared uniforms for this shader.
gsk_gl_shader_get_uniform_name ()
const char * gsk_gl_shader_get_uniform_name (GskGLShader *shader,int idx);
Get the name of the declared uniform for this shader at index idx
.
gsk_gl_shader_find_uniform_by_name ()
int gsk_gl_shader_find_uniform_by_name (GskGLShader *shader,const char *name);
Looks for a uniform by the name name
, and returns the index
of the uniform, or -1 if it was not found.
gsk_gl_shader_get_uniform_type ()
GskGLUniformType gsk_gl_shader_get_uniform_type (GskGLShader *shader,int idx);
Get the type of the declared uniform for this shader at index idx
.
gsk_gl_shader_get_uniform_offset ()
int gsk_gl_shader_get_uniform_offset (GskGLShader *shader,int idx);
Get the offset into the data block where data for this uniforms is stored.
gsk_gl_shader_get_args_size ()
gsize
gsk_gl_shader_get_args_size (GskGLShader *shader);
Get the size of the data block used to specify arguments for this shader.
gsk_gl_shader_get_arg_float ()
float gsk_gl_shader_get_arg_float (GskGLShader *shader,GBytes *args,int idx);
Gets the value of the uniform idx
in the args
block.
The uniform must be of float type.
gsk_gl_shader_get_arg_int ()
gint32 gsk_gl_shader_get_arg_int (GskGLShader *shader,GBytes *args,int idx);
Gets the value of the uniform idx
in the args
block.
The uniform must be of int type.
gsk_gl_shader_get_arg_uint ()
guint32 gsk_gl_shader_get_arg_uint (GskGLShader *shader,GBytes *args,int idx);
Gets the value of the uniform idx
in the args
block.
The uniform must be of uint type.
gsk_gl_shader_get_arg_bool ()
gboolean gsk_gl_shader_get_arg_bool (GskGLShader *shader,GBytes *args,int idx);
Gets the value of the uniform idx
in the args
block.
The uniform must be of bool type.
gsk_gl_shader_get_arg_vec2 ()
void gsk_gl_shader_get_arg_vec2 (GskGLShader *shader,GBytes *args,int idx,graphene_vec2_t *out_value);
Gets the value of the uniform idx
in the args
block.
The uniform must be of vec2 type.
gsk_gl_shader_get_arg_vec3 ()
void gsk_gl_shader_get_arg_vec3 (GskGLShader *shader,GBytes *args,int idx,graphene_vec3_t *out_value);
Gets the value of the uniform idx
in the args
block.
The uniform must be of vec3 type.
gsk_gl_shader_get_arg_vec4 ()
void gsk_gl_shader_get_arg_vec4 (GskGLShader *shader,GBytes *args,int idx,graphene_vec4_t *out_value);
Gets the value of the uniform idx
in the args
block.
The uniform must be of vec4 type.
gsk_gl_shader_format_args_va ()
GBytes * gsk_gl_shader_format_args_va (GskGLShader *shader,va_list uniforms);
Formats the uniform data as needed for feeding the named uniforms
values into the shader. The argument list is a list of pairs of
names, and values for the types that match the declared uniforms
(i.e. double/int/guint/gboolean for primitive values and
graphene_vecN_t * for vecN uniforms).
It is an error to pass a uniform name that is not declared by the shader.
Any uniforms of the shader that are not included in the argument list are zero-initialized.
Returns
A newly allocated block of data which can be
passed to gsk_gl_shader_node_new().
[transfer full]
gsk_gl_shader_format_args ()
GBytes * gsk_gl_shader_format_args (GskGLShader *shader,...);
Formats the uniform data as needed for feeding the named uniforms
values into the shader. The argument list is a list of pairs of
names, and values for the types that match the declared uniforms
(i.e. double/int/guint/gboolean for primitive values and
graphene_vecN_t * for vecN uniforms).
Any uniforms of the shader that are not included in the argument list are zero-initialized.
Returns
A newly allocated block of data which can be
passed to gsk_gl_shader_node_new().
[transfer full]
gsk_shader_args_builder_new ()
GskShaderArgsBuilder * gsk_shader_args_builder_new (GskGLShader *shader,GBytes *initial_values);
gsk_shader_args_builder_to_args ()
GBytes *
gsk_shader_args_builder_to_args (GskShaderArgsBuilder *builder);
Creates a new GBytes args from the current state of the
given builder
. Any uniforms of the shader that have not
been explicitly set on the builder
are zero-initialized.
The given GskShaderArgsBuilder is reset once this function returns;
you cannot call this function multiple times on the same builder
instance.
This function is intended primarily for bindings. C code should use
gsk_shader_args_builder_free_to_args().
gsk_shader_args_builder_free_to_args ()
GBytes *
gsk_shader_args_builder_free_to_args (GskShaderArgsBuilder *builder);
gsk_shader_args_builder_unref ()
void
gsk_shader_args_builder_unref (GskShaderArgsBuilder *builder);
Decreases the reference count of a GskShaderArgBuilder by one. If the resulting reference count is zero, frees the builder.
gsk_shader_args_builder_ref ()
GskShaderArgsBuilder *
gsk_shader_args_builder_ref (GskShaderArgsBuilder *builder);
Increases the reference count of a GskShaderArgsBuilder by one.
gsk_shader_args_builder_set_float ()
void gsk_shader_args_builder_set_float (GskShaderArgsBuilder *builder,int idx,float value);
Sets the value of the uniform idx
.
The uniform must be of float type.
gsk_shader_args_builder_set_int ()
void gsk_shader_args_builder_set_int (GskShaderArgsBuilder *builder,int idx,gint32 value);
Sets the value of the uniform idx
.
The uniform must be of int type.
gsk_shader_args_builder_set_uint ()
void gsk_shader_args_builder_set_uint (GskShaderArgsBuilder *builder,int idx,guint32 value);
Sets the value of the uniform idx
.
The uniform must be of uint type.
gsk_shader_args_builder_set_bool ()
void gsk_shader_args_builder_set_bool (GskShaderArgsBuilder *builder,int idx,gboolean value);
Sets the value of the uniform idx
.
The uniform must be of bool type.
gsk_shader_args_builder_set_vec2 ()
void gsk_shader_args_builder_set_vec2 (GskShaderArgsBuilder *builder,int idx,const graphene_vec2_t *value);
Sets the value of the uniform idx
.
The uniform must be of vec2 type.
gsk_shader_args_builder_set_vec3 ()
void gsk_shader_args_builder_set_vec3 (GskShaderArgsBuilder *builder,int idx,const graphene_vec3_t *value);
Sets the value of the uniform idx
.
The uniform must be of vec3 type.
gsk_shader_args_builder_set_vec4 ()
void gsk_shader_args_builder_set_vec4 (GskShaderArgsBuilder *builder,int idx,const graphene_vec4_t *value);
Sets the value of the uniform idx
.
The uniform must be of vec4 type.
| Top | |
|
|
|
Functions
Types and Values
Description
GskRenderNode is the basic block in a scene graph to be rendered using GskRenderer.
Each node has a parent, except the top-level node; each node may have children nodes.
Each node has an associated drawing surface, which has the size of
the rectangle set using gsk_render_node_set_bounds().
Render nodes are meant to be transient; once they have been associated to a GskRenderer it's safe to release any reference you have on them. All GskRenderNodes are immutable, you can only specify their properties during construction.
Functions
gsk_render_node_ref ()
GskRenderNode *
gsk_render_node_ref (GskRenderNode *node);
Acquires a reference on the given GskRenderNode.
gsk_render_node_unref ()
void
gsk_render_node_unref (GskRenderNode *node);
Releases a reference on the given GskRenderNode.
If the reference was the last, the resources associated to the node
are
freed.
gsk_render_node_get_node_type ()
GskRenderNodeType
gsk_render_node_get_node_type (GskRenderNode *node);
Returns the type of the node
.
gsk_render_node_draw ()
void gsk_render_node_draw (GskRenderNode *node,cairo_t *cr);
Draw the contents of node
to the given cairo context.
Typically, you'll use this function to implement fallback rendering of GskRenderNodes on an intermediate Cairo context, instead of using the drawing context associated to a GdkSurface's rendering buffer.
For advanced nodes that cannot be supported using Cairo, in particular for nodes doing 3D operations, this function may fail.
GskParseErrorFunc ()
void (*GskParseErrorFunc) (const GtkCssSection *section,const GError *error,gpointer user_data);
The type of callback that is called when a parse error occurs during deserialization of node data.
gsk_render_node_serialize ()
GBytes *
gsk_render_node_serialize (GskRenderNode *node);
Serializes the node
for later deserialization via
gsk_render_node_deserialize(). No guarantees are made about the format
used other than that the same version of GTK will be able to deserialize
the result of a call to gsk_render_node_serialize() and
gsk_render_node_deserialize() will correctly reject files it cannot open
that were created with previous versions of GTK.
The intended use of this functions is testing, benchmarking and debugging. The format is not meant as a permanent storage format.
gsk_render_node_deserialize ()
GskRenderNode * gsk_render_node_deserialize (GBytes *bytes,GskParseErrorFunc error_func,gpointer user_data);
Loads data previously created via gsk_render_node_serialize(). For a
discussion of the supported format, see that function.
gsk_render_node_write_to_file ()
gboolean gsk_render_node_write_to_file (GskRenderNode *node,const char *filename,GError **error);
This function is equivalent to calling gsk_render_node_serialize()
followed by g_file_set_contents(). See those two functions for details
on the arguments.
It is mostly intended for use inside a debugger to quickly dump a render node to a file for later inspection.
gsk_render_node_get_bounds ()
void gsk_render_node_get_bounds (GskRenderNode *node,graphene_rect_t *bounds);
Retrieves the boundaries of the node
. The node will not draw outside
of its boundaries.
gsk_color_node_new ()
GskRenderNode * gsk_color_node_new (const GdkRGBA *rgba,const graphene_rect_t *bounds);
Creates a GskRenderNode that will render the color specified by rgba
into
the area given by bounds
.
gsk_color_node_peek_color ()
const GdkRGBA *
gsk_color_node_peek_color (GskRenderNode *node);
Retrieves the color of the given node
.
gsk_texture_node_new ()
GskRenderNode * gsk_texture_node_new (GdkTexture *texture,const graphene_rect_t *bounds);
Creates a GskRenderNode that will render the given
texture
into the area given by bounds
.
gsk_texture_node_get_texture ()
GdkTexture *
gsk_texture_node_get_texture (GskRenderNode *node);
Retrieves the GdkTexture used when creating this GskRenderNode.
gsk_linear_gradient_node_new ()
GskRenderNode * gsk_linear_gradient_node_new (const graphene_rect_t *bounds,const graphene_point_t *start,const graphene_point_t *end,const GskColorStop *color_stops,gsize n_color_stops);
Creates a GskRenderNode that will create a linear gradient from the given
points and color stops, and render that into the area given by bounds
.
Parameters
bounds |
the rectangle to render the linear gradient into |
|
start |
the point at which the linear gradient will begin |
|
end |
the point at which the linear gradient will finish |
|
color_stops |
a pointer to an array of GskColorStop defining the gradient The offsets of all color steps must be increasing. The first stop's offset must be >= 0 and the last stop's offset must be <= 1. |
[array length=n_color_stops] |
n_color_stops |
the number of elements in |
gsk_linear_gradient_node_peek_start ()
const graphene_point_t *
gsk_linear_gradient_node_peek_start (GskRenderNode *node);
Retrieves the initial point of the linear gradient.
gsk_linear_gradient_node_peek_end ()
const graphene_point_t *
gsk_linear_gradient_node_peek_end (GskRenderNode *node);
Retrieves the final point of the linear gradient.
gsk_linear_gradient_node_get_n_color_stops ()
gsize
gsk_linear_gradient_node_get_n_color_stops
(GskRenderNode *node);
Retrieves the number of color stops in the gradient.
gsk_linear_gradient_node_peek_color_stops ()
const GskColorStop * gsk_linear_gradient_node_peek_color_stops (GskRenderNode *node,gsize *n_stops);
Retrieves the color stops in the gradient.
Parameters
node |
a GskRenderNode for a linear gradient. |
[type GskLinearGradientNode] |
n_stops |
the number of color stops in the returned array. |
[out][optional] |
gsk_repeating_linear_gradient_node_new ()
GskRenderNode * gsk_repeating_linear_gradient_node_new (const graphene_rect_t *bounds,const graphene_point_t *start,const graphene_point_t *end,const GskColorStop *color_stops,gsize n_color_stops);
Creates a GskRenderNode that will create a repeating linear gradient
from the given points and color stops, and render that into the area
given by bounds
.
Parameters
bounds |
the rectangle to render the linear gradient into |
|
start |
the point at which the linear gradient will begin |
|
end |
the point at which the linear gradient will finish |
|
color_stops |
a pointer to an array of GskColorStop defining the gradient The offsets of all color steps must be increasing. The first stop's offset must be >= 0 and the last stop's offset must be <= 1. |
[array length=n_color_stops] |
n_color_stops |
the number of elements in |
gsk_radial_gradient_node_new ()
GskRenderNode * gsk_radial_gradient_node_new (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);
Creates a GskRenderNode that draws a radial gradient. The radial gradient
starts around center
. The size of the gradient is dictated by hradius
in horizontal orientation and by vradius
in vertial orientation.
Parameters
bounds |
the bounds of the node |
|
center |
the center of the gradient |
|
hradius |
the horizontal radius |
|
vradius |
the vertical radius |
|
start |
a percentage >= 0 that defines the start of the gradient around |
|
end |
a percentage >= 0 that defines the end of the gradient around |
|
color_stops |
a pointer to an array of GskColorStop defining the gradient The offsets of all color steps must be increasing. The first stop's offset must be >= 0 and the last stop's offset must be <= 1. |
[array length=n_color_stops] |
n_color_stops |
the number of elements in |
gsk_radial_gradient_node_get_n_color_stops ()
gsize
gsk_radial_gradient_node_get_n_color_stops
(GskRenderNode *node);
Retrieves the number of color stops in the gradient.
gsk_radial_gradient_node_peek_color_stops ()
const GskColorStop * gsk_radial_gradient_node_peek_color_stops (GskRenderNode *node,gsize *n_stops);
Retrieves the color stops in the gradient.
Parameters
node |
a GskRenderNode for a radial gradient. |
[type GskRadialGradientNode] |
n_stops |
the number of color stops in the returned array. |
[out][optional] |
gsk_radial_gradient_node_get_start ()
float
gsk_radial_gradient_node_get_start (GskRenderNode *node);
Retrieves the start value for the gradient.
gsk_radial_gradient_node_get_end ()
float
gsk_radial_gradient_node_get_end (GskRenderNode *node);
Retrieves the end value for the gradient.
gsk_radial_gradient_node_get_hradius ()
float
gsk_radial_gradient_node_get_hradius (GskRenderNode *node);
Retrieves the horizonal radius for the gradient.
gsk_radial_gradient_node_get_vradius ()
float
gsk_radial_gradient_node_get_vradius (GskRenderNode *node);
Retrieves the vertical radius for the gradient.
gsk_radial_gradient_node_peek_center ()
const graphene_point_t *
gsk_radial_gradient_node_peek_center (GskRenderNode *node);
Retrieves the center pointer for the gradient.
gsk_repeating_radial_gradient_node_new ()
GskRenderNode * gsk_repeating_radial_gradient_node_new (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);
Creates a GskRenderNode that draws a repeating radial gradient. The radial gradient
starts around center
. The size of the gradient is dictated by hradius
in horizontal orientation and by vradius
in vertial orientation.
Parameters
bounds |
the bounds of the node |
|
center |
the center of the gradient |
|
hradius |
the horizontal radius |
|
vradius |
the vertical radius |
|
start |
a percentage >= 0 that defines the start of the gradient around |
|
end |
a percentage >= 0 that defines the end of the gradient around |
|
color_stops |
a pointer to an array of GskColorStop defining the gradient The offsets of all color steps must be increasing. The first stop's offset must be >= 0 and the last stop's offset must be <= 1. |
[array length=n_color_stops] |
n_color_stops |
the number of elements in |
gsk_border_node_new ()
GskRenderNode * gsk_border_node_new (const GskRoundedRect *outline,const float border_width[4],const GdkRGBA border_color[4]);
Creates a GskRenderNode that will stroke a border rectangle inside the
given outline
. The 4 sides of the border can have different widths and
colors.
Parameters
outline |
a GskRoundedRect describing the outline of the border |
|
border_width |
the stroke width of the border on the top, right, bottom and left side respectively. |
[array fixed-size=4] |
border_color |
the color used on the top, right, bottom and left side. |
[array fixed-size=4] |
gsk_border_node_peek_outline ()
const GskRoundedRect *
gsk_border_node_peek_outline (GskRenderNode *node);
Retrieves the outline of the border.
gsk_border_node_peek_widths ()
const float *
gsk_border_node_peek_widths (GskRenderNode *node);
Retrieves the stroke widths of the border.
gsk_border_node_peek_colors ()
const GdkRGBA *
gsk_border_node_peek_colors (GskRenderNode *node);
Retrieves the colors of the border.
Returns
an array of 4 GdkRGBA structs for the top, right, bottom and left color of the border.
[transfer none]
gsk_inset_shadow_node_new ()
GskRenderNode * gsk_inset_shadow_node_new (const GskRoundedRect *outline,const GdkRGBA *color,float dx,float dy,float spread,float blur_radius);
Creates a GskRenderNode that will render an inset shadow
into the box given by outline
.
gsk_inset_shadow_node_peek_outline ()
const GskRoundedRect *
gsk_inset_shadow_node_peek_outline (GskRenderNode *node);
Retrieves the outline rectangle of the inset shadow.
gsk_inset_shadow_node_peek_color ()
const GdkRGBA *
gsk_inset_shadow_node_peek_color (GskRenderNode *node);
Retrieves the color of the inset shadow.
gsk_inset_shadow_node_get_dx ()
float
gsk_inset_shadow_node_get_dx (GskRenderNode *node);
Retrieves the horizontal offset of the inset shadow.
gsk_inset_shadow_node_get_dy ()
float
gsk_inset_shadow_node_get_dy (GskRenderNode *node);
Retrieves the vertical offset of the inset shadow.
gsk_inset_shadow_node_get_spread ()
float
gsk_inset_shadow_node_get_spread (GskRenderNode *node);
Retrieves how much the shadow spreads inwards.
gsk_inset_shadow_node_get_blur_radius ()
float
gsk_inset_shadow_node_get_blur_radius (GskRenderNode *node);
Retrieves the blur radius to apply to the shadow.
gsk_outset_shadow_node_new ()
GskRenderNode * gsk_outset_shadow_node_new (const GskRoundedRect *outline,const GdkRGBA *color,float dx,float dy,float spread,float blur_radius);
Creates a GskRenderNode that will render an outset shadow
around the box given by outline
.
gsk_outset_shadow_node_peek_outline ()
const GskRoundedRect *
gsk_outset_shadow_node_peek_outline (GskRenderNode *node);
Retrieves the outline rectangle of the outset shadow.
gsk_outset_shadow_node_peek_color ()
const GdkRGBA *
gsk_outset_shadow_node_peek_color (GskRenderNode *node);
Retrieves the color of the outset shadow.
gsk_outset_shadow_node_get_dx ()
float
gsk_outset_shadow_node_get_dx (GskRenderNode *node);
Retrieves the horizontal offset of the outset shadow.
gsk_outset_shadow_node_get_dy ()
float
gsk_outset_shadow_node_get_dy (GskRenderNode *node);
Retrieves the vertical offset of the outset shadow.
gsk_outset_shadow_node_get_spread ()
float
gsk_outset_shadow_node_get_spread (GskRenderNode *node);
Retrieves how much the shadow spreads outwards.
gsk_outset_shadow_node_get_blur_radius ()
float
gsk_outset_shadow_node_get_blur_radius
(GskRenderNode *node);
Retrieves the blur radius of the shadow.
gsk_cairo_node_new ()
GskRenderNode *
gsk_cairo_node_new (const graphene_rect_t *bounds);
Creates a GskRenderNode that will render a cairo surface
into the area given by bounds
. You can draw to the cairo
surface using gsk_cairo_node_get_draw_context()
gsk_cairo_node_get_draw_context ()
cairo_t *
gsk_cairo_node_get_draw_context (GskRenderNode *node);
Creates a Cairo context for drawing using the surface associated to the render node.
If no surface exists yet, a surface will be created optimized for
rendering to renderer
.
gsk_cairo_node_peek_surface ()
cairo_surface_t *
gsk_cairo_node_peek_surface (GskRenderNode *node);
Retrieves the Cairo surface used by the render node.
gsk_container_node_new ()
GskRenderNode * gsk_container_node_new (GskRenderNode **children,guint n_children);
Creates a new GskRenderNode instance for holding the given children
.
The new node will acquire a reference to each of the children.
gsk_container_node_get_n_children ()
guint
gsk_container_node_get_n_children (GskRenderNode *node);
Retrieves the number of direct children of node
.
gsk_container_node_get_child ()
GskRenderNode * gsk_container_node_get_child (GskRenderNode *node,guint idx);
Gets one of the children of container
.
Parameters
node |
a container GskRenderNode. |
[type GskContainerNode] |
idx |
the position of the child to get |
gsk_transform_node_new ()
GskRenderNode * gsk_transform_node_new (GskRenderNode *child,GskTransform *transform);
Creates a GskRenderNode that will transform the given child
with the given transform
.
gsk_transform_node_get_child ()
GskRenderNode *
gsk_transform_node_get_child (GskRenderNode *node);
Gets the child node that is getting transformed by the given node
.
gsk_transform_node_get_transform ()
GskTransform *
gsk_transform_node_get_transform (GskRenderNode *node);
Retrieves the GskTransform used by the node
.
gsk_opacity_node_new ()
GskRenderNode * gsk_opacity_node_new (GskRenderNode *child,float opacity);
Creates a GskRenderNode that will drawn the child
with reduced
opacity
.
gsk_opacity_node_get_child ()
GskRenderNode *
gsk_opacity_node_get_child (GskRenderNode *node);
Gets the child node that is getting opacityed by the given node
.
gsk_opacity_node_get_opacity ()
float
gsk_opacity_node_get_opacity (GskRenderNode *node);
Gets the transparency factor for an opacity node.
gsk_color_matrix_node_new ()
GskRenderNode * gsk_color_matrix_node_new (GskRenderNode *child,const graphene_matrix_t *color_matrix,const graphene_vec4_t *color_offset);
Creates a GskRenderNode that will drawn the child
with reduced
color_matrix
.
In particular, the node will transform the operation
1 |
pixel = color_matrix * pixel + color_offset |
for every pixel.
gsk_color_matrix_node_get_child ()
GskRenderNode *
gsk_color_matrix_node_get_child (GskRenderNode *node);
Gets the child node that is getting its colors modified by the given node
.
gsk_color_matrix_node_peek_color_matrix ()
const graphene_matrix_t *
gsk_color_matrix_node_peek_color_matrix
(GskRenderNode *node);
Retrieves the color matrix used by the node
.
gsk_color_matrix_node_peek_color_offset ()
const graphene_vec4_t *
gsk_color_matrix_node_peek_color_offset
(GskRenderNode *node);
Retrieves the color offset used by the node
.
gsk_repeat_node_new ()
GskRenderNode * gsk_repeat_node_new (const graphene_rect_t *bounds,GskRenderNode *child,const graphene_rect_t *child_bounds);
Creates a GskRenderNode that will repeat the drawing of child
across
the given bounds
.
gsk_repeat_node_get_child ()
GskRenderNode *
gsk_repeat_node_get_child (GskRenderNode *node);
Retrieves the child of node
.
gsk_repeat_node_peek_child_bounds ()
const graphene_rect_t *
gsk_repeat_node_peek_child_bounds (GskRenderNode *node);
Retrieves the bounding rectangle of the child of node
.
gsk_clip_node_new ()
GskRenderNode * gsk_clip_node_new (GskRenderNode *child,const graphene_rect_t *clip);
Creates a GskRenderNode that will clip the child
to the area
given by clip
.
gsk_clip_node_get_child ()
GskRenderNode *
gsk_clip_node_get_child (GskRenderNode *node);
Gets the child node that is getting clipped by the given node
.
gsk_clip_node_peek_clip ()
const graphene_rect_t *
gsk_clip_node_peek_clip (GskRenderNode *node);
Retrieves the clip rectangle for node
.
gsk_rounded_clip_node_new ()
GskRenderNode * gsk_rounded_clip_node_new (GskRenderNode *child,const GskRoundedRect *clip);
Creates a GskRenderNode that will clip the child
to the area
given by clip
.
gsk_rounded_clip_node_get_child ()
GskRenderNode *
gsk_rounded_clip_node_get_child (GskRenderNode *node);
Gets the child node that is getting clipped by the given node
.
gsk_rounded_clip_node_peek_clip ()
const GskRoundedRect *
gsk_rounded_clip_node_peek_clip (GskRenderNode *node);
Retrievs the rounded rectangle used to clip the contents of the node
.
gsk_shadow_node_new ()
GskRenderNode * gsk_shadow_node_new (GskRenderNode *child,const GskShadow *shadows,gsize n_shadows);
Creates a GskRenderNode that will draw a child
with the given
shadows
below it.
gsk_shadow_node_peek_shadow ()
const GskShadow * gsk_shadow_node_peek_shadow (GskRenderNode *node,gsize i);
Retrieves the shadow data at the given index i
.
gsk_shadow_node_get_n_shadows ()
gsize
gsk_shadow_node_get_n_shadows (GskRenderNode *node);
Retrieves the number of shadows in the node
.
gsk_shadow_node_get_child ()
GskRenderNode *
gsk_shadow_node_get_child (GskRenderNode *node);
Retrieves the child GskRenderNode of the shadow node
.
gsk_blend_node_new ()
GskRenderNode * gsk_blend_node_new (GskRenderNode *bottom,GskRenderNode *top,GskBlendMode blend_mode);
Creates a GskRenderNode that will use blend_mode
to blend the top
node onto the bottom
node.
gsk_blend_node_get_bottom_child ()
GskRenderNode *
gsk_blend_node_get_bottom_child (GskRenderNode *node);
Retrieves the bottom GskRenderNode child of the node
.
gsk_blend_node_get_top_child ()
GskRenderNode *
gsk_blend_node_get_top_child (GskRenderNode *node);
Retrieves the top GskRenderNode child of the node
.
gsk_blend_node_get_blend_mode ()
GskBlendMode
gsk_blend_node_get_blend_mode (GskRenderNode *node);
Retrieves the blend mode used by node
.
gsk_cross_fade_node_new ()
GskRenderNode * gsk_cross_fade_node_new (GskRenderNode *start,GskRenderNode *end,float progress);
Creates a GskRenderNode that will do a cross-fade between start
and end
.
gsk_cross_fade_node_get_start_child ()
GskRenderNode *
gsk_cross_fade_node_get_start_child (GskRenderNode *node);
Retrieves the child GskRenderNode at the beginning of the cross-fade.
gsk_cross_fade_node_get_end_child ()
GskRenderNode *
gsk_cross_fade_node_get_end_child (GskRenderNode *node);
Retrieves the child GskRenderNode at the end of the cross-fade.
gsk_cross_fade_node_get_progress ()
float
gsk_cross_fade_node_get_progress (GskRenderNode *node);
Retrieves the progress value of the cross fade.
gsk_text_node_new ()
GskRenderNode * gsk_text_node_new (PangoFont *font,PangoGlyphString *glyphs,const GdkRGBA *color,const graphene_point_t *offset);
Creates a render node that renders the given glyphs,
Note that color
may not be used if the font contains
color glyphs.
Parameters
font |
the PangoFont containing the glyphs |
|
glyphs |
the PangoGlyphString to render |
|
color |
the foreground color to render with |
|
offset |
offset of the baseline |
gsk_text_node_peek_font ()
PangoFont *
gsk_text_node_peek_font (GskRenderNode *node);
Returns the font used by the text node
.
gsk_text_node_peek_glyphs ()
const PangoGlyphInfo * gsk_text_node_peek_glyphs (GskRenderNode *node,guint *n_glyphs);
Retrieves the glyph information in the node
.
Parameters
node |
a text GskRenderNode. |
[type GskTextNode] |
n_glyphs |
the number of glyphs returned. |
[out][optional] |
gsk_text_node_peek_color ()
const GdkRGBA *
gsk_text_node_peek_color (GskRenderNode *node);
Retrieves the color used by the text node
.
gsk_text_node_has_color_glyphs ()
gboolean
gsk_text_node_has_color_glyphs (GskRenderNode *node);
Checks whether the text node
has color glyphs.
gsk_text_node_get_num_glyphs ()
guint
gsk_text_node_get_num_glyphs (GskRenderNode *node);
Retrieves the number of glyphs in the text node.
gsk_text_node_get_offset ()
const graphene_point_t *
gsk_text_node_get_offset (GskRenderNode *node);
Retrieves the offset applied to the text.
gsk_blur_node_new ()
GskRenderNode * gsk_blur_node_new (GskRenderNode *child,float radius);
Creates a render node that blurs the child.
gsk_blur_node_get_child ()
GskRenderNode *
gsk_blur_node_get_child (GskRenderNode *node);
Retrieves the child GskRenderNode of the blur node
.
gsk_blur_node_get_radius ()
float
gsk_blur_node_get_radius (GskRenderNode *node);
Retrieves the blur radius of the node
.
gsk_debug_node_new ()
GskRenderNode * gsk_debug_node_new (GskRenderNode *child,char *message);
Creates a GskRenderNode that will add debug information about
the given child
.
Adding this node has no visual effect.
gsk_debug_node_get_child ()
GskRenderNode *
gsk_debug_node_get_child (GskRenderNode *node);
Gets the child node that is getting drawn by the given node
.
gsk_debug_node_get_message ()
const char *
gsk_debug_node_get_message (GskRenderNode *node);
Gets the debug message that was set on this node
gsk_gl_shader_node_new ()
GskRenderNode * gsk_gl_shader_node_new (GskGLShader *shader,const graphene_rect_t *bounds,GBytes *args,GskRenderNode **children,guint n_children);
Creates a GskRenderNode that will render the given shader
into the
area given by bounds
. The args
is a block of data to use for uniform
input, as per types and offsets defined by the shader
. Normally this
is generated by gsk_gl_shader_format_args() or GskGLShaderArgBuilder.
See GskGLShader for details about how the shader should be written.
All the children will be rendered into textures (if they aren't already GskTextureNodes, which will be used directly). These textures will be sent as input to the shader.
If the renderer doesn't support GL shaders, or if there is any problem
when compiling the shader, then the node will draw pink. You should use
gsk_gl_shader_compile() to ensure the shader
will work for the
renderer before using it.
Parameters
shader |
the GskGLShader |
|
bounds |
the rectangle to render the shader into |
|
args |
Arguments for the uniforms |
|
children |
array of child nodes, these will be rendered to textures and used as input. |
[array length=n_children] |
n_children |
Length of |
gsk_gl_shader_node_get_n_children ()
guint
gsk_gl_shader_node_get_n_children (GskRenderNode *node);
Returns the number of children
gsk_gl_shader_node_get_child ()
GskRenderNode * gsk_gl_shader_node_get_child (GskRenderNode *node,guint idx);
Gets one of the children.
Parameters
node |
a GskRenderNode for a gl shader. |
[type GskGLShaderNode] |
idx |
the position of the child to get |
gsk_gl_shader_node_get_args ()
GBytes *
gsk_gl_shader_node_get_args (GskRenderNode *node);
Gets args for the node.
gsk_gl_shader_node_get_shader ()
GskGLShader *
gsk_gl_shader_node_get_shader (GskRenderNode *node);
Gets shader code for the node.
Types and Values
GskRepeatingLinearGradientNode
typedef struct _GskRepeatingLinearGradientNode GskRepeatingLinearGradientNode;
GskRepeatingRadialGradientNode
typedef struct _GskRepeatingRadialGradientNode GskRepeatingRadialGradientNode;
enum GskRenderNodeType
The type of a node determines what the node is rendering.
Members
|
Error type. No node will ever have this type. |
||
|
A node containing a stack of children |
||
|
A node drawing a cairo_surface_t |
||
|
A node drawing a single color rectangle |
||
|
A node drawing a linear gradient |
||
|
A node drawing a repeating linear gradient |
||
|
A node drawing a radial gradient |
||
|
A node drawing a repeating radial gradient |
||
|
A node stroking a border around an area |
||
|
A node drawing a GdkTexture |
||
|
A node drawing an inset shadow |
||
|
A node drawing an outset shadow |
||
|
A node that renders its child after applying a matrix transform |
||
|
A node that changes the opacity of its child |
||
|
A node that applies a color matrix to every pixel |
||
|
A node that repeats the child's contents |
||
|
A node that clips its child to a rectangular area |
||
|
A node that clips its child to a rounded rectangle |
||
|
A node that draws a shadow below its child |
||
|
A node that blends two children together |
||
|
A node that cross-fades between two children |
||
|
A node containing a glyph string |
||
|
A node that applies a blur |
||
|
Debug information that does not affect the rendering |
||
|
A node that uses OpenGL fragment shaders to render |
enum GskScalingFilter
The filters used when scaling texture data.
The actual implementation of each filter is deferred to the rendering pipeline.
enum GskBlendMode
The blend modes available for render nodes.
The implementation of each blend mode is deferred to the rendering pipeline.
See https://www.w3.org/TR/compositing-1/blending for more information on blending and blend modes.
Members
|
The default blend mode, which specifies no blending |
||
|
The source color is multiplied by the destination and replaces the destination |
||
|
Multiplies the complements of the destination and source color values, then complements the result. |
||
|
Multiplies or screens the colors, depending on the destination color value. This is the inverse of hard-list |
||
|
Selects the darker of the destination and source colors |
||
|
Selects the lighter of the destination and source colors |
||
|
Brightens the destination color to reflect the source color |
||
|
Darkens the destination color to reflect the source color |
||
|
Multiplies or screens the colors, depending on the source color value |
||
|
Darkens or lightens the colors, depending on the source color value |
||
|
Subtracts the darker of the two constituent colors from the lighter color |
||
|
Produces an effect similar to that of the difference mode but lower in contrast |
||
|
Creates a color with the hue and saturation of the source color and the luminosity of the destination color |
||
|
Creates a color with the hue of the source color and the saturation and luminosity of the destination color |
||
|
Creates a color with the saturation of the source color and the hue and luminosity of the destination color |
||
|
Creates a color with the luminosity of the source color and the hue and saturation of the destination color |
| Top | |
|
|
|
Functions
| GdkSurface * | gsk_renderer_get_surface () |
| gboolean | gsk_renderer_realize () |
| void | gsk_renderer_unrealize () |
| gboolean | gsk_renderer_is_realized () |
| void | gsk_renderer_render () |
| GdkTexture * | gsk_renderer_render_texture () |
| GskRenderer * | gsk_renderer_new_for_surface () |
| GskRenderer * | gsk_gl_renderer_new () |
| GskRenderer * | gsk_cairo_renderer_new () |
| GskRenderer * | gsk_vulkan_renderer_new () |
| GskRenderer * | gsk_broadway_renderer_new () |
Description
GskRenderer is a class that renders a scene graph defined via a tree of GskRenderNode instances.
Typically you will use a GskRenderer instance to repeatedly call
gsk_renderer_render() to update the contents of its associated GdkSurface.
It is necessary to realize a GskRenderer instance using gsk_renderer_realize()
before calling gsk_renderer_render(), in order to create the appropriate
windowing system resources needed to render the scene.
Functions
gsk_renderer_get_surface ()
GdkSurface *
gsk_renderer_get_surface (GskRenderer *renderer);
Retrieves the GdkSurface set using gsk_renderer_realize(). If the renderer
has not been realized yet, NULL will be returned.
gsk_renderer_realize ()
gboolean gsk_renderer_realize (GskRenderer *renderer,GdkSurface *surface,GError **error);
Creates the resources needed by the renderer
to render the scene
graph.
Parameters
renderer |
||
surface |
the GdkSurface renderer will be used on |
|
error |
return location for an error |
gsk_renderer_unrealize ()
void
gsk_renderer_unrealize (GskRenderer *renderer);
Releases all the resources created by gsk_renderer_realize().
gsk_renderer_is_realized ()
gboolean
gsk_renderer_is_realized (GskRenderer *renderer);
Checks whether the renderer
is realized or not.
gsk_renderer_render ()
void gsk_renderer_render (GskRenderer *renderer,GskRenderNode *root,const cairo_region_t *region);
Renders the scene graph, described by a tree of GskRenderNode instances,
ensuring that the given region
gets redrawn.
Renderers must ensure that changes of the contents given by the root
node as well as the area given by region
are redrawn. They are however
free to not redraw any pixel outside of region
if they can guarantee that
it didn't change.
The renderer
will acquire a reference on the GskRenderNode tree while
the rendering is in progress.
Parameters
renderer |
||
root |
||
region |
the cairo_region_t that must be redrawn or |
[nullable] |
gsk_renderer_render_texture ()
GdkTexture * gsk_renderer_render_texture (GskRenderer *renderer,GskRenderNode *root,const graphene_rect_t *viewport);
Renders the scene graph, described by a tree of GskRenderNode instances, to a GdkTexture.
The renderer
will acquire a reference on the GskRenderNode tree while
the rendering is in progress.
If you want to apply any transformations to root
, you should put it into a
transform node and pass that node instead.
Parameters
renderer |
a realized GskRenderer |
|
root |
||
viewport |
the section to draw or |
[allow-none] |
gsk_renderer_new_for_surface ()
GskRenderer *
gsk_renderer_new_for_surface (GdkSurface *surface);
Creates an appropriate GskRenderer instance for the given surface
.
The renderer will be realized when it is returned.
gsk_gl_renderer_new ()
GskRenderer *
gsk_gl_renderer_new (void);
Creates a new GskRenderer using OpenGL. This is the default renderer used by GTK.
gsk_cairo_renderer_new ()
GskRenderer *
gsk_cairo_renderer_new (void);
Creates a new Cairo renderer.
The Cairo renderer is the fallback renderer drawing in ways similar to how GTK 3 drew its content. Its primary use is as comparison tool.
The Cairo renderer is incomplete. It cannot render 3D transformed content and will instead render an error marker. Its usage should be avoided.
gsk_vulkan_renderer_new ()
GskRenderer *
gsk_vulkan_renderer_new (void);
Creates a new Vulkan renderer.
The Vulkan renderer is a renderer that uses the Vulkan library for rendering.
This function is only available when GTK was compiled with Vulkan support.
gsk_broadway_renderer_new ()
GskRenderer *
gsk_broadway_renderer_new (void);
Creates a new Broadway renderer.
The Broadway renderer is the default renderer for the broadway backend.
It will only work with broadway surfaces, otherwise it will fail the
call to gsk_renderer_realize().
This function is only available when GTK was compiled with Broadway support.
Property Details
The “realized” property
“realized” gboolean
The renderer has been associated with a surface.
Owner: GskRenderer
Flags: Read
Default value: FALSE
The “surface” property
“surface” GdkSurface *
The surface associated to the renderer.
Owner: GskRenderer
Flags: Read
|
 |
|
 |
A
NULL is OK, both for passing and for returning.
Parameter points to an array of items.
C
This parameter is a 'user_data', for callbacks; many bindings can pass NULL here.
N
NULL may be passed as the value in, out, in-out; or as a return value.
O
NULL may be passed instead of a pointer to a location.
Parameter for returning results. Default is transfer full.
Out parameter, where caller must allocate storage.
S
The callback is valid only during the call to the method.
T
Free data after the code is done.
Don't free data after the code is done.
Override the parsed C type with given type.
|
|
|
|
B
C
D
G
I
L
O
P
R
S
T
V
| Top | |
|
|
|
Functions
| #define | GSK_ROUNDED_RECT_INIT() |
| GskRoundedRect * | gsk_rounded_rect_init () |
| GskRoundedRect * | gsk_rounded_rect_init_copy () |
| GskRoundedRect * | gsk_rounded_rect_init_from_rect () |
| GskRoundedRect * | gsk_rounded_rect_normalize () |
| GskRoundedRect * | gsk_rounded_rect_offset () |
| GskRoundedRect * | gsk_rounded_rect_shrink () |
| gboolean | gsk_rounded_rect_is_rectilinear () |
| gboolean | gsk_rounded_rect_contains_point () |
| gboolean | gsk_rounded_rect_contains_rect () |
| gboolean | gsk_rounded_rect_intersects_rect () |
Description
GskRoundedRect defines a rectangle with rounded corners, as is commonly used in drawing.
Operations on a GskRoundedRect will normalize the rectangle, to ensure that the bounds are normalized and that the corner sizes don't exceed the size of the rectangle. The algorithm used for normalizing corner sizes is described in the CSS specification.
Functions
GSK_ROUNDED_RECT_INIT()
#define GSK_ROUNDED_RECT_INIT(_x,_y,_w,_h)
Initializes a GskRoundedRect when declaring it. All corner sizes will be initialized to 0.
gsk_rounded_rect_init ()
GskRoundedRect * gsk_rounded_rect_init (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);
Initializes the given GskRoundedRect with the given values.
This function will implicitly normalize the GskRoundedRect before returning.
Parameters
self |
The GskRoundedRect to initialize |
|
bounds |
a graphene_rect_t describing the bounds |
|
top_left |
the rounding radius of the top left corner |
|
top_right |
the rounding radius of the top right corner |
|
bottom_right |
the rounding radius of the bottom right corner |
|
bottom_left |
the rounding radius of the bottom left corner |
gsk_rounded_rect_init_copy ()
GskRoundedRect * gsk_rounded_rect_init_copy (GskRoundedRect *self,const GskRoundedRect *src);
Initializes self
using the given src
rectangle.
This function will not normalize the GskRoundedRect, so make sure the source is normalized.
gsk_rounded_rect_init_from_rect ()
GskRoundedRect * gsk_rounded_rect_init_from_rect (GskRoundedRect *self,const graphene_rect_t *bounds,float radius);
Initializes self
to the given bounds
and sets the radius of all
four corners to radius
.
gsk_rounded_rect_normalize ()
GskRoundedRect *
gsk_rounded_rect_normalize (GskRoundedRect *self);
Normalizes the passed rectangle.
this function will ensure that the bounds of the rectangle are normalized and ensure that the corner values are positive and the corners do not overlap.
gsk_rounded_rect_offset ()
GskRoundedRect * gsk_rounded_rect_offset (GskRoundedRect *self,float dx,float dy);
Offsets the bound's origin by dx
and dy
.
The size and corners of the rectangle are unchanged.
gsk_rounded_rect_shrink ()
GskRoundedRect * gsk_rounded_rect_shrink (GskRoundedRect *self,float top,float right,float bottom,float left);
Shrinks (or grows) the given rectangle by moving the 4 sides according to the offsets given. The corner radii will be changed in a way that tries to keep the center of the corner circle intact. This emulates CSS behavior.
This function also works for growing rectangles if you pass
negative values for the top
, right
, bottom
or left
.
Parameters
self |
The GskRoundedRect to shrink or grow |
|
top |
How far to move the top side downwards |
|
right |
How far to move the right side to the left |
|
bottom |
How far to move the bottom side upwards |
|
left |
How far to move the left side to the right |
gsk_rounded_rect_is_rectilinear ()
gboolean
gsk_rounded_rect_is_rectilinear (const GskRoundedRect *self);
Checks if all corners of self
are right angles and the
rectangle covers all of its bounds.
This information can be used to decide if gsk_clip_node_new()
or gsk_rounded_clip_node_new() should be called.
gsk_rounded_rect_contains_point ()
gboolean gsk_rounded_rect_contains_point (const GskRoundedRect *self,const graphene_point_t *point);
Checks if the given point
is inside the rounded rectangle. This function
returns FALSE if the point is in the rounded corner areas.
gsk_rounded_rect_contains_rect ()
gboolean gsk_rounded_rect_contains_rect (const GskRoundedRect *self,const graphene_rect_t *rect);
Checks if the given rect
is contained inside the rounded rectangle.
This function returns FALSE if rect
extends into one of the rounded
corner areas.
gsk_rounded_rect_intersects_rect ()
gboolean gsk_rounded_rect_intersects_rect (const GskRoundedRect *self,const graphene_rect_t *rect);
Checks if part of the given rect
is contained inside the rounded rectangle.
This function returns FALSE if rect
only extends into one of the rounded
corner areas but not into the rounded rectangle itself.
Types and Values
struct GskRoundedRect
struct GskRoundedRect {
graphene_rect_t bounds;
graphene_size_t corner[4];
};
A rectangular region with rounded corners.
Application code should normalize rectangles using gsk_rounded_rect_normalize();
this function will ensure that the bounds of the rectangle are normalized
and ensure that the corner values are positive and the corners do not overlap.
All functions taking a GskRoundedRect as an argument will internally operate on
a normalized copy; all functions returning a GskRoundedRect will always return
a normalized one.
Members
graphene_rect_t |
the bounds of the rectangle |
|
graphene_size_t |
the size of the 4 rounded corners |
| Top | |
|
|
|
Functions
| GskTransform * | gsk_transform_ref () |
| void | gsk_transform_unref () |
| GskTransformCategory | gsk_transform_get_category () |
| void | gsk_transform_print () |
| char * | gsk_transform_to_string () |
| gboolean | gsk_transform_parse () |
| void | gsk_transform_to_matrix () |
| void | gsk_transform_to_2d () |
| void | gsk_transform_to_affine () |
| void | gsk_transform_to_translate () |
| GskTransform * | gsk_transform_transform () |
| GskTransform * | gsk_transform_invert () |
| GskTransform * | gsk_transform_matrix () |
| GskTransform * | gsk_transform_translate () |
| GskTransform * | gsk_transform_translate_3d () |
| GskTransform * | gsk_transform_rotate () |
| GskTransform * | gsk_transform_rotate_3d () |
| GskTransform * | gsk_transform_scale () |
| GskTransform * | gsk_transform_scale_3d () |
| GskTransform * | gsk_transform_perspective () |
| gboolean | gsk_transform_equal () |
| void | gsk_transform_transform_bounds () |
| void | gsk_transform_transform_point () |
Description
GskTransform is an object to describe transform matrices. Unlike graphene_matrix_t, GskTransform retains the steps in how a transform was constructed, and allows inspecting them. It is modeled after the way CSS describes transforms.
GskTransform objects are immutable and cannot be changed after creation. This means code can safely expose them as properties of objects without having to worry about others changing them.
Functions
gsk_transform_ref ()
GskTransform *
gsk_transform_ref (GskTransform *self);
Acquires a reference on the given GskTransform.
gsk_transform_unref ()
void
gsk_transform_unref (GskTransform *self);
Releases a reference on the given GskTransform.
If the reference was the last, the resources associated to the self
are
freed.
gsk_transform_get_category ()
GskTransformCategory
gsk_transform_get_category (GskTransform *self);
Returns the category this transform belongs to.
gsk_transform_print ()
void gsk_transform_print (GskTransform *self,GString *string);
Converts self
into a human-readable string representation suitable
for printing that can later be parsed with gsk_transform_parse().
gsk_transform_to_string ()
char *
gsk_transform_to_string (GskTransform *self);
Converts a matrix into a string that is suitable for
printing and can later be parsed with gsk_transform_parse().
This is a wrapper around gsk_transform_print(), see that function
for details.
gsk_transform_parse ()
gboolean gsk_transform_parse (const char *string,GskTransform **out_transform);
Parses the given string
into a transform and puts it in
out_transform
. Strings printed via gsk_transform_to_string()
can be read in again successfully using this function.
If string
does not describe a valid transform, FALSE is
returned and NULL is put in out_transform
.
gsk_transform_to_matrix ()
void gsk_transform_to_matrix (GskTransform *self,graphene_matrix_t *out_matrix);
Computes the actual value of self
and stores it in out_matrix
.
The previous value of out_matrix
will be ignored.
gsk_transform_to_2d ()
void gsk_transform_to_2d (GskTransform *self,float *out_xx,float *out_yx,float *out_xy,float *out_yy,float *out_dx,float *out_dy);
Converts a GskTransform to a 2D transformation
matrix.
self
must be a 2D transformation. If you are not
sure, use gsk_transform_get_category() >=
GSK_TRANSFORM_CATEGORY_2D to check.
The returned values have the following layout:
1 2 3 |
| xx yx | | a b 0 | | xy yy | = | c d 0 | | dx dy | | tx ty 1 | |
This function can be used to convert between a GskTransform and a matrix type from other 2D drawing libraries, in particular Cairo.
Parameters
self |
a 2D GskTransform |
|
out_xx |
return location for the xx member. |
[out] |
out_yx |
return location for the yx member. |
[out] |
out_xy |
return location for the xy member. |
[out] |
out_yy |
return location for the yy member. |
[out] |
out_dx |
return location for the x0 member. |
[out] |
out_dy |
return location for the y0 member. |
[out] |
gsk_transform_to_affine ()
void gsk_transform_to_affine (GskTransform *self,float *out_scale_x,float *out_scale_y,float *out_dx,float *out_dy);
Converts a GskTransform to 2D affine transformation
factors.
self
must be a 2D transformation. If you are not
sure, use gsk_transform_get_category() >=
GSK_TRANSFORM_CATEGORY_2D_AFFINE to check.
Parameters
self |
||
out_scale_x |
return location for the scale factor in the x direction. |
[out] |
out_scale_y |
return location for the scale factor in the y direction. |
[out] |
out_dx |
return location for the translation in the x direction. |
[out] |
out_dy |
return location for the translation in the y direction. |
[out] |
gsk_transform_to_translate ()
void gsk_transform_to_translate (GskTransform *self,float *out_dx,float *out_dy);
Converts a GskTransform to a translation operation.
self
must be a 2D transformation. If you are not
sure, use gsk_transform_get_category() >=
GSK_TRANSFORM_CATEGORY_2D_TRANSLATE to check.
gsk_transform_transform ()
GskTransform * gsk_transform_transform (GskTransform *next,GskTransform *other);
Applies all the operations from other
to next
.
gsk_transform_invert ()
GskTransform *
gsk_transform_invert (GskTransform *self);
Inverts the given transform.
If self
is not invertible, NULL is returned.
Note that inverting NULL also returns NULL, which is
the correct inverse of NULL. If you need to differentiate
between those cases, you should check self
is not NULL
before calling this function.
gsk_transform_matrix ()
GskTransform * gsk_transform_matrix (GskTransform *next,const graphene_matrix_t *matrix);
Multiplies next
with the given matrix
.
gsk_transform_translate ()
GskTransform * gsk_transform_translate (GskTransform *next,const graphene_point_t *point);
Translates next
in 2dimensional space by point
.
gsk_transform_translate_3d ()
GskTransform * gsk_transform_translate_3d (GskTransform *next,const graphene_point3d_t *point);
Translates next
by point
.
gsk_transform_rotate ()
GskTransform * gsk_transform_rotate (GskTransform *next,float angle);
Rotates next
angle
degrees in 2D - or in 3Dspeak, around the z axis.
gsk_transform_rotate_3d ()
GskTransform * gsk_transform_rotate_3d (GskTransform *next,float angle,const graphene_vec3_t *axis);
Rotates next
angle
degrees around axis
.
For a rotation in 2D space, use gsk_transform_rotate().
gsk_transform_scale ()
GskTransform * gsk_transform_scale (GskTransform *next,float factor_x,float factor_y);
Scales next
in 2-dimensional space by the given factors.
Use gsk_transform_scale_3d() to scale in all 3 dimensions.
gsk_transform_scale_3d ()
GskTransform * gsk_transform_scale_3d (GskTransform *next,float factor_x,float factor_y,float factor_z);
Scales next
by the given factors.
gsk_transform_perspective ()
GskTransform * gsk_transform_perspective (GskTransform *next,float depth);
Applies a perspective projection transform. This transform scales points in X and Y based on their Z value, scaling points with positive Z values away from the origin, and those with negative Z values towards the origin. Points on the z=0 plane are unchanged.
gsk_transform_equal ()
gboolean gsk_transform_equal (GskTransform *first,GskTransform *second);
Checks two transforms for equality.
gsk_transform_transform_bounds ()
void gsk_transform_transform_bounds (GskTransform *self,const graphene_rect_t *rect,graphene_rect_t *out_rect);
Transforms a graphene_rect_t using the given transform self
.
The result is the bounding box containing the coplanar quad.
gsk_transform_transform_point ()
void gsk_transform_transform_point (GskTransform *self,const graphene_point_t *point,graphene_point_t *out_point);
Transforms a graphene_point_t using the given transform self
.
Types and Values
GskTransform
typedef struct _GskTransform GskTransform;
The GskTransform structure contains only private data.
enum GskTransformCategory
The categories of matrices relevant for GSK and GTK. Note that any
category includes matrices of all later categories. So if you want
to for example check if a matrix is a 2D matrix,
category >= GSK_TRANSFORM_CATEGORY_2D is the way to do this.
Also keep in mind that rounding errors may cause matrices to not
conform to their categories. Otherwise, matrix operations done via
mutliplication will not worsen categories. So for the matrix
multiplication C = A * B, category(C) = MIN (category(A), category(B)).
Members
|
The category of the matrix has not been determined. |
||
|
Analyzing the matrix concluded that it does not fit in any other category. |
||
|
The matrix is a 3D matrix. This means that the w column (the last column) has the values (0, 0, 0, 1). |
||
|
The matrix is a 2D matrix. This is equivalent
to |
||
|
The matrix is a combination of 2D scale and 2D translation operations. In particular, this means that any rectangle can be transformed exactly using this matrix. |
||
|
The matrix is a 2D translation. |
||
|
The matrix is the identity matrix. |
GSK 4 Reference Manual |
|---|
This document is for the GSK 4 library, version 3.99.2 The latest versions can be found online at https://developer.gnome.org/gsk4/.
- I. API Reference
- GskRenderer — Renders a scene
- GskRenderNode — Simple scene graph element
- GskRoundedRect — A rounded rectangle
- GskTransform — A description for transform operations
- GskGLShader — Fragment shaders for GSK
- Index of all symbols
- Annotation Glossary
|
|
|
|
Table of Contents
- GskRenderer — Renders a scene
- GskRenderNode — Simple scene graph element
- GskRoundedRect — A rounded rectangle
- GskTransform — A description for transform operations
- GskGLShader — Fragment shaders for GSK