sampicore 0.4.0

🐶 Take a screenshot get a shareable URL
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

use crate::piston::Window;
use glutin_window::GlutinWindow;
use graphics::draw_state::DrawState;
use graphics::*;
use opengl_graphics::{GlGraphics, OpenGL, Texture, TextureSettings};
use piston::event_loop::{EventSettings, Events};
use piston::input::*;
use piston::input::{RenderArgs, RenderEvent};
use piston::window::WindowSettings;
use std::path::Path;

pub struct App {
    gl: GlGraphics, // OpenGL drawing backend.
}
impl App {
    fn render(
        &mut self,
        args: &RenderArgs,
        image: &Image,
        texture: &Texture,
        &rect: &rectangle::Rectangle,
        &initial_cursor_pos: &[f64; 2],
        &cursor_pos: &[f64; 2],
        &initial_cursor_pos_set: &bool,
        &draw_state: &DrawState,
    ) {
        self.gl.draw(args.viewport(), |c, gl| {
            image.draw(texture, &draw_state, c.transform, gl);
            if !initial_cursor_pos_set {
                return;
            };
            rect.draw(
                [
                    initial_cursor_pos[0],
                    initial_cursor_pos[1],
                    cursor_pos[0] - initial_cursor_pos[0],
                    cursor_pos[1] - initial_cursor_pos[1],
                ],
                &draw_state,
                c.transform,
                gl,
            );
        });
    }
}

pub fn get_region(screenshot_path: &str) -> Option<[f64; 4]> {
    // Change this to OpenGL::V2_1 if not working.
    let opengl = OpenGL::V3_2;

    // Create an Glutin window.
    let mut window: GlutinWindow = WindowSettings::new("sampic", [200, 200])
        .fullscreen(true)
        .decorated(false)
        .graphics_api(opengl)
        .exit_on_esc(true)
        .samples(2)
        .build()
        .unwrap();

    // Create a new game and run it.
    let mut app = App {
        gl: GlGraphics::new(opengl),
    };

    let texture_settings = TextureSettings::new();
    let image = Image::new();
    //A texture to use with the image
    let texture = Texture::from_path(
        Path::new(&screenshot_path),
        &texture_settings,
    )
    .unwrap();
    let draw_state = &DrawState::new_alpha();

    let mut events = Events::new(EventSettings::new());
    let mut initial_cursor_pos = [0.0, 0.0];
    let mut initial_cursor_pos_set = false;
    let mut cursor_pos = [1.0, 1.0];

    const COLOR: [f32; 4] = [1.0, 1.0, 0.0, 0.1];

    let rect = rectangle::Rectangle::new(COLOR).border(rectangle::Border {
        color: COLOR,
        radius: 1.0,
    });
    while let Some(e) = events.next(&mut window) {
        e.mouse_cursor(|pos| {
            if initial_cursor_pos_set {
                let x: f64;
                let y: f64;
                if pos[0] > initial_cursor_pos[0] {
                    x = pos[0];
                } else {
                    x = initial_cursor_pos[0];
                };
                if pos[1] > initial_cursor_pos[1] {
                    y = pos[1];
                } else {
                    y = initial_cursor_pos[1];
                };
                cursor_pos = [x, y];
            } else {
                initial_cursor_pos = pos;
            };
        });
        if let Some(Button::Mouse(_)) = e.press_args() {
            initial_cursor_pos_set = true;
        };
        if let Some(Button::Mouse(_)) = e.release_args() {
            window.set_should_close(true);
        };
        if let Some(args) = e.render_args() {
            app.render(
                &args,
                &image,
                &texture,
                &rect,
                &initial_cursor_pos,
                &cursor_pos,
                &initial_cursor_pos_set,
                &draw_state,
            );
        }
    }
    return Some([
        initial_cursor_pos[0],
        initial_cursor_pos[1],
        cursor_pos[0] - initial_cursor_pos[0],
        cursor_pos[1] - initial_cursor_pos[1],
    ]);
}