omn-sprites 0.1.0

A small library for sprite sheet animation.
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


extern crate ggez;
extern crate rand;
extern crate time;

extern crate omn_sprites;


use std::time::Duration;
use std::rc::Rc;
use std::cell::RefCell;

use ggez::conf;
use ggez::event;
use ggez::{GameResult, Context};
use ggez::graphics::{self, DrawParam, Image};

use omn_sprites::{SpriteSheetData, AnimationClip, ClipStore, PlayMode};


struct MainState {
    clip: Option<RefCell<AnimationClip>>,
    sheet: Rc<SpriteSheetData>,
    clips: Rc<ClipStore>,
    image: Image,
}


impl MainState {
    fn new(ctx: &mut Context) -> GameResult<MainState> {
        ctx.print_resource_stats();
        let sheet = Rc::new(SpriteSheetData::from_file(
            "resources/numbers-matrix-tags.array.json",
        ));
        let clips = Rc::new(ClipStore::new(sheet.as_ref()));
        let mut s = MainState {
            clips: clips,
            clip: None,
            sheet: sheet.clone(),
            image: Image::new(ctx, "/numbers-matrix.png").unwrap(),
        };
        s.clip = Some(RefCell::new(
            s.clips.create("Alpha", PlayMode::Loop).unwrap(),
        ));
        Ok(s)
    }
}


impl event::EventHandler for MainState {
    fn update(&mut self, _ctx: &mut Context, _dt: Duration) -> GameResult<()> {

        if let Some(ref clip) = self.clip {
            let delta_millis = _dt.subsec_nanos() as f32 / 1e6;
            clip.borrow_mut().update(delta_millis)
        }
        Ok(())
    }

    fn draw(&mut self, ctx: &mut Context) -> GameResult<()> {
        graphics::clear(ctx);

        if let Some(ref clip) = self.clip {

            let w = self.image.width() as f32;
            let h = self.image.height() as f32;

            let idx = clip.borrow().get_cell().unwrap();
            let cell = &self.sheet.frames[idx];
            let param = DrawParam {
                src: graphics::Rect::new(
                    cell.bbox.x as f32 / w,
                    cell.bbox.y as f32 / h,
                    cell.bbox.width as f32 / w,
                    cell.bbox.height as f32 / h,
                ),
                dest: graphics::Point::new(160., 120.),
                scale: graphics::Point::new(1.5, 1.5),
                ..Default::default()
            };
            graphics::draw_ex(ctx, &self.image, param)?;
        }

        graphics::present(ctx);
        Ok(())
    }
}


fn main() {

    let mut conf = conf::Conf::new();
    conf.window_width = 320;
    conf.window_height = 240;
    conf.window_title = "Omn Sprites".to_string();

    println!("Starting with default config: {:#?}", conf);
    let ctx = &mut Context::load_from_conf("Omn Sprites", "omn_sprites", conf).unwrap();
    let state = &mut MainState::new(ctx).unwrap();
    event::run(ctx, state).unwrap();
}