implicit 0.1.0

A library for playing with 2d implicit geometry
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

#![allow(dead_code)]

extern crate implicit;
extern crate lux;

use lux::prelude::*;
use lux::interactive::Event;

use implicit::*;
use implicit::geom::Point;

struct DisplayCanvas {
    zoom: f32,
    scene: Scene,
}

fn handle_events<I>(canvas: &mut DisplayCanvas, events: I, dirty: &mut bool)
where I: Iterator<Item=Event> {
    for event in events {
        match event {
            Event::WindowResized((x, y)) => {
                let (x, y) = (x as f32, y as f32);
                let m = x.min(y);
                canvas.zoom = m / 100.0;
                *dirty = true;
            }
            Event::KeyReleased(_, Some('j'), _) => {
                canvas.scene.resolution *= 1.5f32;
                *dirty = true;
            }
            Event::KeyReleased(_, Some('k'), _) => {
                canvas.scene.resolution /= 1.5f32;
                *dirty = true;
            }
            Event::KeyReleased(_, Some('h'), _) => {
                canvas.zoom *= 0.75;
                *dirty = true;
            }
            Event::KeyReleased(_, Some('l'), _) => {
                canvas.zoom *= 1.5;
                *dirty = true;
            }
            _ => {}
        }
    }
}

pub struct DrawStateHolder<'a>(&'a mut DrawState, &'a mut Frame, f32);

#[derive(Copy, Clone)]
pub enum DrawState {
    Start,
    Middle(f32, f32),
}

impl <'a> OutputDevice for DrawStateHolder<'a> {
    fn start_line(&mut self) {
        *self.0 = DrawState::Start;
    }

    fn add_point(&mut self, Point{x, y}: Point) {
        let s = self.2;
        if let DrawState::Middle(px, py) = *self.0 {
            self.1.draw_line(px * s, py * s, x * s, y * s, 1.0);
        }
        *self.0 = DrawState::Middle(x, y);
    }

    fn end_line(&mut self) {
        *self.0 = DrawState::Start;
    }
}

pub fn display(scene: Scene) {
    let mut canvas = DisplayCanvas {
        zoom: 1.0,
        scene: scene,
    };
    let mut window = Window::new_with_defaults().unwrap();
    let mut dirty = true;

    loop {
        handle_events(&mut canvas, window.events(), &mut dirty);
        if dirty {
            dirty = false;
            let mut frame = window.cleared_frame(rgb(1.0, 1.0, 1.0));
            canvas.scene.render_all(&mut DrawStateHolder(&mut DrawState::Start, &mut frame, canvas.zoom));
        }
    }
}

fn main() {
    panic!("not actually an example");
}