thorvg 0.5.0

Safe Rust bindings to the ThorVG vector graphics library
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164

//! Demonstrates complex path construction: Bézier curves, stars, spirals, and custom shapes.
//!
//! Run with: `cargo run --example paths`
//! Output:   `paths.png`

#![allow(clippy::cast_precision_loss, clippy::too_many_lines)]

mod common;

use thorvg::{ColorSpace, EngineOption, StrokeCap, StrokeJoin, Rgba, Rect, Thorvg};

fn main() {
    let engine = Thorvg::init(0).unwrap();
    let (w, h) = (800u32, 600u32);
    let mut buffer = vec![0u32; (w * h) as usize];
    let mut canvas = engine.sw_canvas(EngineOption::Default).unwrap();
    unsafe { canvas.set_target(&mut buffer, w, w, h, ColorSpace::ABGR8888) }.unwrap();

    // Background
    let mut bg = engine.shape().unwrap();
    bg.append_rect(Rect::new(0.0, 0.0, w as f32, h as f32))
        .unwrap();
    bg.set_fill_color(Rgba::new(15, 15, 25, 255)).unwrap();
    canvas.add(bg).unwrap();

    // ── 5-pointed star ─────────────────────────────────────────────
    let mut star = engine.shape().unwrap();
    let (cx, cy) = (120.0f32, 140.0f32);
    let (outer, inner) = (80.0f32, 35.0f32);
    for i in 0..10 {
        let angle = core::f32::consts::PI * i as f32 / 5.0 - core::f32::consts::FRAC_PI_2;
        let r = if i % 2 == 0 { outer } else { inner };
        let px = cx + angle.cos() * r;
        let py = cy + angle.sin() * r;
        if i == 0 {
            star.move_to(px, py).unwrap();
        } else {
            star.line_to(px, py).unwrap();
        }
    }
    star.close().unwrap();
    star.set_fill_color(Rgba::new(255, 200, 0, 255)).unwrap();
    star.set_stroke_width(2.0).unwrap();
    star.set_stroke_color(Rgba::new(255, 255, 200, 255)).unwrap();
    canvas.add(star).unwrap();

    // ── Heart shape (cubic Béziers) ────────────────────────────────
    let mut heart = engine.shape().unwrap();
    let hx = 320.0f32;
    let hy = 160.0f32;
    heart.move_to(hx, hy).unwrap();
    heart
        .cubic_to(
            hx - 5.0,
            hy - 60.0,
            hx - 100.0,
            hy - 60.0,
            hx - 100.0,
            hy - 10.0,
        )
        .unwrap();
    heart
        .cubic_to(hx - 100.0, hy + 30.0, hx, hy + 80.0, hx, hy + 100.0)
        .unwrap();
    heart
        .cubic_to(hx, hy + 80.0, hx + 100.0, hy + 30.0, hx + 100.0, hy - 10.0)
        .unwrap();
    heart
        .cubic_to(hx + 100.0, hy - 60.0, hx + 5.0, hy - 60.0, hx, hy)
        .unwrap();
    heart.close().unwrap();
    heart.set_fill_color(Rgba::new(220, 30, 60, 255)).unwrap();
    canvas.add(heart).unwrap();

    // ── Spiral (stroked path) ──────────────────────────────────────
    let mut spiral = engine.shape().unwrap();
    let (sx, sy) = (580.0f32, 140.0f32);
    spiral.move_to(sx, sy).unwrap();
    let turns = 4.0f32;
    let steps = 200;
    for i in 1..=steps {
        let t = i as f32 / steps as f32;
        let angle = turns * 2.0 * core::f32::consts::PI * t;
        let r = 5.0 + 80.0 * t;
        let px = sx + angle.cos() * r;
        let py = sy + angle.sin() * r;
        spiral.line_to(px, py).unwrap();
    }
    spiral.set_stroke_width(2.5).unwrap();
    spiral.set_stroke_color(Rgba::new(100, 200, 255, 255)).unwrap();
    spiral.set_stroke_cap(StrokeCap::Round).unwrap();
    canvas.add(spiral).unwrap();

    // ── Wavy line ──────────────────────────────────────────────────
    let mut wave = engine.shape().unwrap();
    wave.move_to(50.0, 420.0).unwrap();
    let segments = 12;
    let seg_w = 60.0f32;
    for i in 0..segments {
        let x0 = 50.0 + i as f32 * seg_w;
        let dir = if i % 2 == 0 { -60.0 } else { 60.0 };
        wave.cubic_to(
            x0 + seg_w * 0.33,
            420.0 + dir,
            x0 + seg_w * 0.66,
            420.0 + dir,
            x0 + seg_w,
            420.0,
        )
        .unwrap();
    }
    wave.set_stroke_width(4.0).unwrap();
    wave.set_stroke_color(Rgba::new(255, 150, 50, 255)).unwrap();
    wave.set_stroke_cap(StrokeCap::Round).unwrap();
    wave.set_stroke_join(StrokeJoin::Round).unwrap();
    canvas.add(wave).unwrap();

    // ── Polygon (hexagon) ──────────────────────────────────────────
    let mut hex = engine.shape().unwrap();
    let (hcx, hcy, hr) = (150.0f32, 520.0f32, 50.0f32);
    for i in 0..6 {
        let angle = core::f32::consts::PI * i as f32 / 3.0 - core::f32::consts::FRAC_PI_2;
        let px = hcx + angle.cos() * hr;
        let py = hcy + angle.sin() * hr;
        if i == 0 {
            hex.move_to(px, py).unwrap();
        } else {
            hex.line_to(px, py).unwrap();
        }
    }
    hex.close().unwrap();
    hex.set_fill_color(Rgba::new(60, 180, 120, 200)).unwrap();
    hex.set_stroke_width(3.0).unwrap();
    hex.set_stroke_color(Rgba::new(200, 255, 200, 255)).unwrap();
    canvas.add(hex).unwrap();

    // ── Arrow shape ────────────────────────────────────────────────
    let mut arrow = engine.shape().unwrap();
    arrow.move_to(350.0, 500.0).unwrap();
    arrow.line_to(500.0, 530.0).unwrap();
    arrow.line_to(350.0, 560.0).unwrap();
    arrow.line_to(380.0, 530.0).unwrap();
    arrow.close().unwrap();
    arrow.set_fill_color(Rgba::new(255, 100, 200, 255)).unwrap();
    canvas.add(arrow).unwrap();

    // ── Infinity symbol (figure-8 with Béziers) ────────────────────
    let mut inf = engine.shape().unwrap();
    let ix = 620.0f32;
    let iy = 530.0f32;
    inf.move_to(ix, iy).unwrap();
    inf.cubic_to(ix + 70.0, iy - 70.0, ix + 130.0, iy + 70.0, ix + 70.0, iy)
        .unwrap();
    inf.cubic_to(ix + 10.0, iy - 70.0, ix - 60.0, iy + 70.0, ix, iy)
        .unwrap();
    inf.set_stroke_width(4.0).unwrap();
    inf.set_stroke_color(Rgba::new(200, 200, 255, 255)).unwrap();
    inf.set_stroke_cap(StrokeCap::Round).unwrap();
    canvas.add(inf).unwrap();

    canvas.draw(true).unwrap();
    canvas.sync().unwrap();
    common::save_png("paths.png", &buffer, w, h);
}