crayon 0.7.1

A small, portable and extensible game framework.
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

use serde_json;
use uuid::Uuid;

use crate::application::ins::Inspectable;
use crate::video::prelude::VideoSystemShared;

#[derive(Copy, Clone, Debug, Serialize)]
pub struct VideoInspectResourceField {
    pub size: u32,
    pub rc: u32,
    pub uuid: Option<Uuid>,
}

#[derive(Debug, Serialize)]
pub struct VideoInspectFields {
    pub meshes: Vec<VideoInspectResourceField>,
    pub textures: Vec<VideoInspectResourceField>,
    pub render_textures: Vec<VideoInspectResourceField>,
}

impl Inspectable for VideoSystemShared {
    fn inspect(&self, buf: &mut Vec<u8>) {
        let mut fields = VideoInspectFields {
            textures: Vec::new(),
            meshes: Vec::new(),
            render_textures: Vec::new(),
        };

        self.textures.iter(|_, value, rc, uuid| {
            fields.textures.push(VideoInspectResourceField {
                size: value.format.size(value.dimensions),
                rc: rc,
                uuid: uuid,
            });
        });

        self.meshes.iter(|_, value, rc, uuid| {
            fields.meshes.push(VideoInspectResourceField {
                size: (value.vertex_buffer_len() + value.index_buffer_len()) as u32,
                rc: rc,
                uuid: uuid,
            });
        });

        {
            let render_textures = self.render_textures.read().unwrap();
            for (_, v) in render_textures.iter() {
                fields.render_textures.push(VideoInspectResourceField {
                    size: v.format.size(v.dimensions),
                    rc: 1,
                    uuid: None,
                });
            }
        }

        let json = serde_json::to_string(&fields).unwrap();
        buf.extend_from_slice(json.as_bytes());
    }
}