graphics_buffer 0.3.1

A buffer which can be used as a render target for Piston's graphics library. This buffer can be loaded from and/or saved to a file on disk. This allows for things like screenshots in games.
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

extern crate graphics;
extern crate graphics_buffer;
extern crate piston_window;

use graphics::{ellipse, image, text, Transformed};
use graphics_buffer::*;
use piston_window::{
    clear, Event, Loop, PistonWindow, TextureSettings, UpdateArgs, WindowSettings,
};

fn main() {
    // Load Matt Damon
    let matt = RenderBuffer::from_bytes(include_bytes!("matt.jpg")).unwrap();

    // Load the font and initialize glyphs
    let mut glyphs = BufferGlyphs::from_bytes(include_bytes!("roboto.ttf")).unwrap();

    // Initalize the buffer
    let mut buffer = RenderBuffer::new(matt.width(), matt.height());
    buffer.clear([0.0, 0.0, 0.0, 1.0]);

    // Draw Matt to the buffer
    image(&matt, identity(), &mut buffer);

    // Give Matt red eyes
    let red = [1.0, 0.0, 0.0, 0.7];
    let diameter = 40.0;
    ellipse(
        red,
        [115.0, 175.0, diameter, diameter],
        identity(),
        &mut buffer,
    );
    ellipse(
        red,
        [210.0, 195.0, diameter, diameter],
        identity(),
        &mut buffer,
    );

    // Let people know he is woke
    text(
        [0.0, 1.0, 0.0, 1.0],
        70,
        "# w o k e",
        &mut glyphs,
        identity().trans(40.0, 70.0),
        &mut buffer,
    ).unwrap();

    // Create a window
    let mut window: PistonWindow = WindowSettings::new(
        "piston_window texture example",
        (matt.height(), matt.height()),
    ).exit_on_esc(true)
        .build()
        .unwrap();

    // Create a texture from red-eyed Matt
    let matt_texture = buffer
        .to_g2d_texture(&mut window.factory, &TextureSettings::new())
        .unwrap();

    // Initialize a rotation
    let mut rot = 0.0;

    while let Some(event) = window.next() {
        match event {
            Event::Loop(Loop::Render(..)) => {
                window.draw_2d(&event, |c, g| {
                    // Clear window with black
                    clear([0.0, 0.0, 0.0, 1.0], g);
                    // Draw matt rotated and scaled
                    image(
                        &matt_texture,
                        c.transform
                            .trans(matt.height() as f64 / 2.0, matt.height() as f64 / 2.0)
                            .scale(0.5, 0.5)
                            .rot_rad(rot),
                        g,
                    );
                });
            }
            // Rotate on update
            Event::Loop(Loop::Update(UpdateArgs { dt, .. })) => rot += dt,
            _ => (),
        }
    }

    // Save the image
    buffer.save("red_eyes.png").unwrap();
}