a2d 0.1.11

A 2D graphics library
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

extern crate a2d;
use a2d::Graphics2D;
use a2d::Instance;
use a2d::SpriteSheetDesc;
use futures::executor::block_on;
use winit::{
    dpi::LogicalSize,
    event::{ElementState, Event, KeyboardInput, VirtualKeyCode, WindowEvent},
    event_loop::{ControlFlow, EventLoop},
    window::WindowBuilder,
};

pub fn main() {
    // simple_logger::init_with_level(log::Level::Debug).unwrap();
    let event_loop = EventLoop::new();
    let window = WindowBuilder::new()
        .with_inner_size(LogicalSize {
            width: 1200,
            height: 800,
        })
        .build(&event_loop)
        .unwrap();

    let size = window.inner_size();
    let mut state = block_on(Graphics2D::new(size.width, size.height, &window)).unwrap();
    state.set_scale([1200.0 / 800.0, 1.0]);
    state
        .set_sheet(0, SpriteSheetDesc::Bytes(include_bytes!("happy-tree.png")))
        .unwrap();
    state.set_batch(0, 0).unwrap();
    let batch = state.get_batch_mut(0).unwrap();
    batch.add(
        Instance::builder()
            .src([0.0, 0.0, 0.75, 0.75])
            .dest([0.25, 0.25, 0.75, 0.75])
            .rotate(3.14 / 3.0)
            .build(),
    );
    batch.add(
        Instance::builder()
            .src([0.0, 0.0, 0.5, 0.5])
            .dest([0.0, 0.0, 0.25, 0.25])
            .rotate(0.0)
            .build(),
    );
    batch.add(
        Instance::builder()
            .src([0.75, 0.75, 1.0, 1.0])
            .dest([0.5, 0.5, 1.0, 1.0])
            .rotate(0.0)
            .build(),
    );
    batch.add(
        Instance::builder()
            .src([0.0, 0.75, 0.2, 1.0])
            .dest([0.5, 0.5, 1.0, 1.0])
            .rotate(0.0)
            .build(),
    );
    batch.add(
        Instance::builder()
            .src([0.0, 0.75, 0.2, 1.0])
            .dest([-0.1, 0.0, 0.1, 0.1])
            .rotate(0.0)
            .build(),
    );

    let start = std::time::SystemTime::now();

    event_loop.run(move |event, _, control_flow| match event {
        Event::RedrawRequested(_) => {
            {
                let instance = state.get_batch_mut(0).unwrap().get_mut(0);
                let dur = start.elapsed().unwrap().as_secs_f32();
                instance.set_rotation((dur / 6.0).fract() * 2.0 * std::f32::consts::PI);
            }
            state.render();
            std::thread::yield_now();
        }
        Event::MainEventsCleared => {
            window.request_redraw();
        }
        Event::WindowEvent {
            ref event,
            window_id,
        } if window_id == window.id() => match event {
            WindowEvent::CloseRequested => *control_flow = ControlFlow::Exit,
            WindowEvent::KeyboardInput { input, .. } => match input {
                KeyboardInput {
                    state: ElementState::Pressed,
                    virtual_keycode: Some(VirtualKeyCode::Escape),
                    ..
                } => {
                    *control_flow = ControlFlow::Exit;
                }
                KeyboardInput {
                    state: ElementState::Pressed,
                    virtual_keycode: Some(code),
                    ..
                } => match code {
                    VirtualKeyCode::Up => {
                        let scale = state.scale();
                        let scale = [scale[0] * 2.0, scale[1] * 2.0];
                        state.set_scale(scale);
                    }
                    VirtualKeyCode::Down => {
                        let scale = state.scale();
                        let scale = [scale[0] / 2.0, scale[1] / 2.0];
                        state.set_scale(scale);
                    }
                    _ => {}
                },
                _ => {}
            },
            WindowEvent::Resized(physical_size) => {
                state.resized(physical_size.width, physical_size.height);
            }
            WindowEvent::ScaleFactorChanged { new_inner_size, .. } => {
                state.resized(new_inner_size.width, new_inner_size.height);
            }
            _ => {}
        },
        _ => {}
    })
}