Struct tiny_skia::Path

pub struct Path { /* private fields */ }

A Bezier path.

Can be created via PathBuilder. Where PathBuilder can be created from the Path using clear to reuse the allocation.

Path is immutable and uses compact storage, where segment types and numbers are stored separately. Use can access path segments via Path::verbs and Path::points, or via Path::segments

Guarantees

• Has a valid, precomputed bounds.
• All points are finite.
• Has at least two segments.
• Each contour starts with a MoveTo.
• No duplicated Move.
• No duplicated Close.
• Zero-length contours are allowed.

Implementations

impl Path

pub fn dash(&self, dash: &StrokeDash, resolution_scale: f32) -> Option<Path>

Converts the current path into a dashed one.

resolution_scale can be obtained via compute_resolution_scale.

Returns None when more than 1_000_000 dashes had to be produced or when the final path has an invalid bounding box.

impl Path

pub fn len(&self) -> usize

Returns the number of segments in the path.

pub fn is_empty(&self) -> bool

Return if the path is empty.

pub fn bounds(&self) -> Rect

Returns the bounds of the path’s points.

The value is already calculated.

pub fn compute_tight_bounds(&self) -> Option<Rect>

Calculates path’s tight bounds.

This operation can be expensive.

pub fn verbs(&self) -> &[PathVerb]

Returns an internal vector of verbs.

pub fn points(&self) -> &[Point]

Returns an internal vector of points.

pub fn transform(self, ts: Transform) -> Option<Path>

Returns a transformed in-place path.

Some points may become NaN/inf therefore this method can fail.

Examples found in repository

examples/mask.rs (line 12)

fn main() {
    let clip_path = {
        let mut pb = PathBuilder::new();
        pb.push_circle(250.0, 250.0, 200.0);
        pb.push_circle(250.0, 250.0, 100.0);
        pb.finish().unwrap()
    };

    let clip_path = clip_path
        .transform(Transform::from_row(1.0, -0.3, 0.0, 1.0, 0.0, 75.0))
        .unwrap();

    let mut mask = Mask::new(500, 500).unwrap();
    mask.fill_path(&clip_path, FillRule::EvenOdd, true, Transform::default());

    let mut paint = Paint::default();
    paint.anti_alias = false;
    paint.set_color_rgba8(50, 127, 150, 200);

    let mut pixmap = Pixmap::new(500, 500).unwrap();
    pixmap.fill_rect(
        Rect::from_xywh(0.0, 0.0, 500.0, 500.0).unwrap(),
        &paint,
        Transform::identity(),
        Some(&mask),
    );
    pixmap.save_png("image.png").unwrap();
}

pub fn segments(&self) -> PathSegmentsIter<'_>

Returns an iterator over path’s segments.

pub fn clear(self) -> PathBuilder

Clears the path and returns a PathBuilder that will reuse an allocated memory.

impl Path

pub fn stroke(&self, stroke: &Stroke, resolution_scale: f32) -> Option<Path>

Returns a stoked path.

resolution_scale can be obtained via compute_resolution_scale.

If you plan stroking multiple paths, you can try using PathStroker which will preserve temporary allocations required during stroking. This might improve performance a bit.

Trait Implementations

impl Clone for Path

fn clone(&self) -> Path

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Path

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter.

impl PartialEq for Path

fn eq(&self, other: &Path) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl StructuralPartialEq for Path