pix-engine 0.8.0

A cross-platform graphics/UI engine framework for simple games, visualizations, and graphics demos.
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

use pix_engine::prelude::*;

struct Shapes {
    rotation: f64,
    scale: f64,
    scale_latch: bool,
}

impl PixEngine for Shapes {
    fn on_start(&mut self, s: &mut PixState) -> PixResult<()> {
        s.background(50);
        s.stroke(Color::BLACK);
        Ok(())
    }

    fn on_update(&mut self, s: &mut PixState) -> PixResult<()> {
        s.clear()?;

        s.stroke(Color::CYAN);
        for x in (10..210).step_by(3) {
            s.point([x, x])?;
        }

        s.stroke(Color::RED);
        s.line([[10, 200], [300, 200]])?;

        s.stroke(Color::LIGHT_YELLOW);
        s.line([[185, 20], [110, 10]])?;
        s.line([[190, 90], [115, 80]])?;
        s.stroke(Color::STEEL_BLUE);
        s.bezier([[185, 20], [110, 10], [190, 90], [115, 80]])?;

        s.stroke(Color::YELLOW);
        s.fill(Color::DARK_BLUE);
        s.triangle([[230, 20], [250, 180], [400, 155]])?;

        s.stroke(Color::GAINSBORO);
        s.fill(Color::DARK_ORANGE);
        s.square([20, 220, 100])?;

        s.stroke(Color::REBECCA_PURPLE);
        s.fill(Color::LIGHT_SEA_GREEN);
        s.rounded_rect([150, 220, 150, 100], 16)?;

        s.stroke(Color::CORNFLOWER_BLUE);
        s.fill(None);
        s.quad([[360, 30], [380, 120], [500, 160], [520, 40]])?;

        s.stroke(None);
        s.fill(Color::CORAL);
        s.polygon([[320, 230], [320, 320], [460, 360], [520, 240], [400, 300]])?;

        s.stroke(Color::CRIMSON);
        s.fill(None);
        let delta = s.delta_time().as_secs_f64();
        self.rotation += delta;
        if self.scale_latch {
            self.scale -= 50.0 * delta;
        } else {
            self.scale += 50.0 * delta;
        }
        if self.scale >= 120.0 || self.scale <= 20.0 {
            self.scale_latch = !self.scale_latch;
        }
        s.wireframe(
            [[1.0, 1.0], [0.0, 0.0], [0.0, 1.0], [1.0, 0.0]],
            [650, 160],
            self.rotation,
            self.scale,
        )?;

        s.ellipse_mode(EllipseMode::Center);
        s.fill(Color::SEA_GREEN);
        s.ellipse([70, 370, 120, 60])?;

        s.ellipse_mode(EllipseMode::Corner);
        s.fill(Color::SANDY_BROWN);
        s.circle([160, 340, 50])?;

        s.arc_mode(ArcMode::Default);
        s.stroke(Color::DARK_VIOLET);
        s.arc([350, 400], 50, 0, 200)?;

        s.arc_mode(ArcMode::Pie);
        s.stroke(Color::LIGHT_GOLDENROD_YELLOW);
        s.fill(Color::OLIVE_DRAB);
        s.arc([480, 420], 50, 100, 300)?;

        Ok(())
    }
}

fn main() -> PixResult<()> {
    let mut engine = Engine::builder()
        .dimensions(800, 600)
        .title("Shapes")
        .target_frame_rate(60)
        .build()?;
    let mut app = Shapes {
        rotation: 0.0,
        scale: 50.0,
        scale_latch: false,
    };
    engine.run(&mut app)
}