## Path Primitives Path Primitives — Functions for constructing and drawing 2D paths. |

## Synopsis

    gboolean            cogl_is_path                        (void *object);
    #define             cogl_path_new
    CoglPath *          cogl_path_copy                      (CoglPath *path);
    #define             cogl_path_move_to
    #define             cogl_path_close
    #define             cogl_path_line_to
    #define             cogl_path_curve_to
    #define             cogl_path_arc
    #define             cogl_path_rel_move_to
    #define             cogl_path_rel_line_to
    #define             cogl_path_rel_curve_to
    #define             cogl_path_line
    #define             cogl_path_polyline
    #define             cogl_path_polygon
    #define             cogl_path_rectangle
    #define             cogl_path_round_rectangle
    #define             cogl_path_ellipse

    enum                CoglPathFillRule;
    #define             cogl_path_set_fill_rule
    #define             cogl_path_get_fill_rule
    #define             cogl_path_fill
    #define             cogl_path_stroke

## Description

There are two levels on which drawing with cogl-paths can be used. The highest level functions construct various simple primitive shapes to be either filled or stroked. Using a lower-level set of functions more complex and arbitrary paths can be constructed by concatenating straight line, bezier curve and arc segments.

When constructing arbitrary paths, the current pen location is initialized using the move_to command. The subsequent path segments implicitly use the last pen location as their first vertex and move the pen location to the last vertex they produce at the end. Also there are special versions of functions that allow specifying the vertices of the path segments relative to the last pen location rather then in the absolute coordinates.

## Details

### cogl_is_path ()

    gboolean            cogl_is_path                        (void *object);

Gets whether the given object references an existing path object.

`object` : | A CoglObject
Returns : | `TRUE` if the object references a CoglPath, `FALSE` otherwise.

Since 2.0

### cogl_path_new

    #define cogl_path_new cogl2_path_new

Creates a new, empty path object. The default fill rule is `COGL_PATH_FILL_RULE_EVEN_ODD`.

Returns : | A pointer to a newly allocated CoglPath, which can be freed using `cogl_object_unref()`.

Since 2.0

### cogl_path_copy ()

    CoglPath *          cogl_path_copy                      (CoglPath *path);

Returns a new copy of the path in `path`. The new path has a reference count of 1 so you should unref it with `cogl_object_unref()` if you no longer need it.

Internally the path will share the data until one of the paths is modified so copying paths should be relatively cheap.

`path` : | A CoglPath object
Returns : | a copy of the path in `path`.

Since 2.0

### cogl_path_move_to

    #define cogl_path_move_to cogl2_path_move_to

Moves the pen to the given location. If there is an existing path this will start a new disjoint subpath.

`x` : | X coordinate of the pen location to move to.
`y` : | Y coordinate of the pen location to move to.

Since 2.0

### cogl_path_close

    #define cogl_path_close cogl2_path_close

Closes the path being constructed by adding a straight line segment to it that ends at the first vertex of the path.

Since 2.0

### cogl_path_line_to

    #define cogl_path_line_to cogl2_path_line_to

Adds a straight line segment to the current path that ends at the given coordinates.

`x` : | X coordinate of the end line vertex
`y` : | Y coordinate of the end line vertex

Since 2.0

### cogl_path_curve_to

    #define cogl_path_curve_to cogl2_path_curve_to

Adds a cubic bezier curve segment to the current path with the given second, third and fourth control points and using current pen location as the first control point.

`x_1` : | X coordinate of the second bezier control point
`y_1` : | Y coordinate of the second bezier control point
`x_2` : | X coordinate of the third bezier control point
`y_2` : | Y coordinate of the third bezier control point
`x_3` : | X coordinate of the fourth bezier control point
`y_3` : | Y coordinate of the fourth bezier control point

Since 2.0

### cogl_path_arc

    #define cogl_path_arc cogl2_path_arc

Adds an elliptical arc segment to the current path. A straight line segment will link the current pen location with the first vertex of the arc. If you perform a move_to to the arcs start just before drawing it you create a free standing arc.

The angles are measured in degrees where 0° is in the direction of the positive X axis and 90° is in the direction of the positive Y axis. The angle of the arc begins at `angle_1` and heads towards `angle_2` (so if `angle_2` is less than `angle_1` it will decrease, otherwise it will increase).

`center_x` : | X coordinate of the elliptical arc center
`center_y` : | Y coordinate of the elliptical arc center
`radius_x` : | X radius of the elliptical arc
`radius_y` : | Y radius of the elliptical arc
`angle_1` : | Angle in degrees at which the arc begin
`angle_2` : | Angle in degrees at which the arc ends

Since 2.0

### cogl_path_rel_move_to

    #define cogl_path_rel_move_to cogl2_path_rel_move_to

Moves the pen to the given offset relative to the current pen location. If there is an existing path this will start a new disjoint subpath.

`x` : | X offset from the current pen location to move the pen to.
`y` : | Y offset from the current pen location to move the pen to.

Since 2.0

### cogl_path_rel_line_to

    #define cogl_path_rel_line_to cogl2_path_rel_line_to

Adds a straight line segment to the current path that ends at the given coordinates relative to the current pen location.

`x` : | X offset from the current pen location of the end line vertex
`y` : | Y offset from the current pen location of the end line vertex

Since 2.0

### cogl_path_rel_curve_to

    #define cogl_path_rel_curve_to cogl2_path_rel_curve_to

Adds a cubic bezier curve segment to the current path with the given second, third and fourth control points and using current pen location as the first control point. The given coordinates are relative to the current pen location.

`x_1` : | X coordinate of the second bezier control point
`y_1` : | Y coordinate of the second bezier control point
`x_2` : | X coordinate of the third bezier control point
`y_2` : | Y coordinate of the third bezier control point
`x_3` : | X coordinate of the fourth bezier control point
`y_3` : | Y coordinate of the fourth bezier control point

Since 2.0

### cogl_path_line

    #define cogl_path_line cogl2_path_line

Constructs a straight line shape starting and ending at the given coordinates. If there is an existing path this will start a new disjoint sub-path.

`x_1` : | X coordinate of the start line vertex
`y_1` : | Y coordinate of the start line vertex
`x_2` : | X coordinate of the end line vertex
`y_2` : | Y coordinate of the end line vertex

Since 2.0

### cogl_path_polyline

    #define cogl_path_polyline cogl2_path_polyline

Constructs a series of straight line segments, starting from the first given vertex coordinate. If there is an existing path this will start a new disjoint sub-path. Each subsequent segment starts where the previous one ended and ends at the next given vertex coordinate.

The coords array must contain 2 * num_points values. The first value represents the X coordinate of the first vertex, the second value represents the Y coordinate of the first vertex, continuing in the same fashion for the rest of the vertices. (num_points - 1) segments will be constructed.

`coords` : | A pointer to the first element of an array of fixed-point values that specify the vertex coordinates. [in][array][transfer none]
`num_points` : | The total number of vertices.

Since 2.0

### cogl_path_polygon

    #define cogl_path_polygon cogl2_path_polygon

Constructs a polygonal shape of the given number of vertices. If there is an existing path this will start a new disjoint sub-path.

The coords array must contain 2 * num_points values. The first value represents the X coordinate of the first vertex, the second value represents the Y coordinate of the first vertex, continuing in the same fashion for the rest of the vertices.

`coords` : | A pointer to the first element of an array of fixed-point values that specify the vertex coordinates. [in][array][transfer none]
`num_points` : | The total number of vertices.

Since 2.0

### cogl_path_rectangle

    #define cogl_path_rectangle cogl2_path_rectangle

Constructs a rectangular shape at the given coordinates. If there is an existing path this will start a new disjoint sub-path.

`x_1` : | X coordinate of the top-left corner.
`y_1` : | Y coordinate of the top-left corner.
`x_2` : | X coordinate of the bottom-right corner.
`y_2` : | Y coordinate of the bottom-right corner.

Since 2.0

### cogl_path_round_rectangle

    #define cogl_path_round_rectangle cogl2_path_round_rectangle

Constructs a rectangular shape with rounded corners. If there is an existing path this will start a new disjoint sub-path.

`x_1` : | X coordinate of the top-left corner.
`y_1` : | Y coordinate of the top-left corner.
`x_2` : | X coordinate of the bottom-right corner.
`y_2` : | Y coordinate of the bottom-right corner.
`radius` : | Radius of the corner arcs.
`arc_step` : | Angle increment resolution for subdivision of the corner arcs.

Since 2.0

### cogl_path_ellipse

    #define cogl_path_ellipse cogl2_path_ellipse

Constructs an ellipse shape. If there is an existing path this will start a new disjoint sub-path.

`center_x` : | X coordinate of the ellipse center
`center_y` : | Y coordinate of the ellipse center
`radius_x` : | X radius of the ellipse
`radius_y` : | Y radius of the ellipse

Since 2.0

### enum CoglPathFillRule

    typedef enum {
      COGL_PATH_FILL_RULE_NON_ZERO,
      COGL_PATH_FILL_RULE_EVEN_ODD
    } CoglPathFillRule;

CoglPathFillRule is used to determine how a path is filled. There are two options - 'non-zero' and 'even-odd'. To work out whether any point will be filled imagine drawing an infinetely long line in any direction from that point. The number of times and the direction that the edges of the path crosses this line determines whether the line is filled as described below. Any open sub paths are treated as if there was an extra line joining the first point and the last point.

The default fill rule is `COGL_PATH_FILL_RULE_EVEN_ODD`. The fill rule is attached to the current path so preserving a path with `cogl_get_path()` also preserves the fill rule. Calling `cogl_path_new()` resets the current fill rule to the default.

Figure 2. Example of filling various paths using the non-zero rule

Figure 3. Example of filling various paths using the even-odd rule

`COGL_PATH_FILL_RULE_NON_ZERO` | Each time the line crosses an edge of the path from left to right one is added to a counter and each time it crosses from right to left the counter is decremented. If the counter is non-zero then the point will be filled. See Figure 2, “Example of filling various paths using the non-zero rule”.
`COGL_PATH_FILL_RULE_EVEN_ODD` | If the line crosses an edge of the path an odd number of times then the point will filled, otherwise it won't. See Figure 3, “Example of filling various paths using the even-odd rule”.

Since 1.4

### cogl_path_set_fill_rule

    #define cogl_path_set_fill_rule cogl2_path_set_fill_rule

Sets the fill rule of the current path to `fill_rule`. This will affect how the path is filled when `cogl_path_fill()` is later called. Note that the fill rule state is attached to the path so calling `cogl_get_path()` will preserve the fill rule and calling `cogl_path_new()` will reset the fill rule back to the default.

`fill_rule` : | The new fill rule.

Since 2.0

### cogl_path_get_fill_rule

    #define cogl_path_get_fill_rule cogl2_path_get_fill_rule

Retrieves the fill rule set using `cogl_path_set_fill_rule()`.

Returns : | the fill rule that is used for the current path.

Since 2.0

### cogl_path_fill

    #define cogl_path_fill cogl2_path_fill

Fills the interior of the constructed shape using the current drawing color.

The interior of the shape is determined using the fill rule of the path. See `CoglPathFillRule` for details.

### Note

The result of referencing sliced textures in your current pipeline when filling a path are undefined. You should pass the `COGL_TEXTURE_NO_SLICING` flag when loading any texture you will use while filling a path.

Since 2.0

### cogl_path_stroke

    #define cogl_path_stroke cogl2_path_stroke

Strokes the constructed shape using the current drawing color and a width of 1 pixel (regardless of the current transformation matrix).

Since 2.0