glowygraph 0.8.0

A library for drawing glowy graphs
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

extern crate glium;
extern crate glowygraph as gg;
extern crate rand;
use rand::{Isaac64Rng, Rng, SeedableRng};
use glium::glutin;

use gg::render2::*;

const TOTAL_BEZIERS: usize = 8192;

fn main() {
    let mut events_loop = glutin::EventsLoop::new();
    let context = glutin::ContextBuilder::new().with_depth_buffer(24);
    let window_builder = glutin::WindowBuilder::new();
    let display = glium::Display::new(window_builder, context, &events_loop).unwrap();
    let glowy = Renderer::new(&display);

    let mut rng = Isaac64Rng::from_seed(&[5, 1, 2, 6]);

    loop {
        use glium::Surface;

        // Get dimensions
        let dims = display.get_framebuffer_dimensions();
        let hscale = dims.1 as f32 / dims.0 as f32;

        let qbeziers = (0..TOTAL_BEZIERS)
            .map(|_| {
                let basepos = [rng.gen_range(-1.0, 1.0), rng.gen_range(-1.0, 1.0)];
                QBezier {
                    position0: [
                        (basepos[0] + rng.gen_range(-0.1, 0.1)) / hscale,
                        basepos[1] + rng.gen_range(-0.1, 0.1),
                    ],
                    position1: [
                        (basepos[0] + rng.gen_range(-0.1, 0.1)) / hscale,
                        basepos[1] + rng.gen_range(-0.1, 0.1),
                    ],
                    position2: [
                        (basepos[0] + rng.gen_range(-0.1, 0.1)) / hscale,
                        basepos[1] + rng.gen_range(-0.1, 0.1),
                    ],
                    inner_color0: [
                        rng.next_f32(),
                        rng.next_f32(),
                        rng.next_f32(),
                        rng.next_f32(),
                    ],
                    inner_color1: [
                        rng.next_f32(),
                        rng.next_f32(),
                        rng.next_f32(),
                        rng.next_f32(),
                    ],
                    falloff_color0: [
                        rng.next_f32(),
                        rng.next_f32(),
                        rng.next_f32(),
                        rng.next_f32(),
                    ],
                    falloff_color1: [
                        rng.next_f32(),
                        rng.next_f32(),
                        rng.next_f32(),
                        rng.next_f32(),
                    ],
                    falloff0: rng.gen_range(0.0, 1.0),
                    falloff1: rng.gen_range(0.0, 1.0),
                    falloff_radius0: rng.gen_range(0.001, 0.002),
                    falloff_radius1: rng.gen_range(0.001, 0.002),
                    inner_radius0: rng.gen_range(0.001, 0.002),
                    inner_radius1: rng.gen_range(0.001, 0.002),
                }
            })
            .collect::<Vec<_>>();

        let mut target = display.draw();
        target.clear_color(0.0, 0.0, 0.0, 1.0);

        // Render nodes
        glowy.render_qbeziers_flat(
            &mut target,
            [[1.0, 0.0, 0.0], [0.0, 1.0, 0.0], [0.0, 0.0, 1.0]],
            [[hscale, 0.0, 0.0], [0.0, 1.0, 0.0], [0.0, 0.0, 1.0]],
            &qbeziers,
        );

        target.finish().unwrap();

        events_loop.poll_events(|event| match event {
            glutin::Event::WindowEvent { event, .. } => match event {
                glutin::WindowEvent::Closed => ::std::process::exit(0),
                _ => (),
            },
            _ => (),
        });
    }
}