tgr2 0.1.0

Simple game engine for Rust
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
133
134
135
136
137
138
139
140
141
142
143
144

use hashbrown::HashMap;
use std::any::Any;

use crate::render::Ctx;
use crate::app::App;
use crate::cross::*;
use crate::draw::*;


#[derive(Default)]
pub struct Group {
    object_list: HashMap<String, Box<dyn Node>>,
}
impl Group {
    pub fn add(&mut self, name: &str, object: impl Node) {
        self.object_list.insert(name.to_string(), Box::new(object));
    }
    pub fn len(&self) -> usize {
        self.object_list.len()
    }
}
impl Node for Group {
    fn update(&mut self, app: &App) {
        for (_, obj) in &mut self.object_list {
            obj.update(app);
        }
    }
    fn draw(&mut self, ctx: &mut Ctx, mvp: &Mat4) {
        for (_, obj) in &mut self.object_list {
            obj.draw(ctx, mvp);
        }
    }
}


pub struct Factory {
    object_list: Vec<Object>,
}
impl Factory {
    pub fn new() -> Self {
        Self {
            object_list: Vec::new(),
        }
    }
    pub fn add(&mut self, obj: Object) {
        self.object_list.push(obj);
    }
}
impl Node for Factory {
    fn update(&mut self, app: &App) {
        cross_chunks(&mut self.object_list, 1000).for_each(|chunk| {
            for obj in chunk {
                obj.update(app);
            }
        });
    }
    fn draw(&mut self, ctx: &mut Ctx, mvp: &Mat4) {
        for obj in &mut self.object_list {
            obj.draw(ctx, mvp);
        }
    }
}


pub struct Object {
    pub modules: ModulesObject,
    draw: Draw,

    pub position: Vec3,
    pub scale: Vec3,
    pub rotation: Vec3,
    pub color: Color,
}
impl Object {
    pub(crate) fn new(draw: Draw) -> Self {
        Self {
            modules: ModulesObject::default(),
            draw,

            position: Vec3::ZERO,
            scale: Vec3::ONE,
            rotation: Vec3::ZERO,
            color: Color::ONE,
        }
    }
}
impl Node for Object {
    fn update(&mut self, app: &App) {
        if self.modules.is_size() {
            let mut modules = take(&mut self.modules);
            modules.update(app, self);
            self.modules = modules;
        }
    }
    fn draw(&mut self, ctx: &mut Ctx, mvp: &Mat4) {
        let position = Mat4::from_translation(self.position);

        let scale = Mat4::from_scale(self.scale);

        let rot_x = Mat4::from_rotation_x(self.rotation.x);
        let rot_y = Mat4::from_rotation_y(self.rotation.y);
        let rot_z = Mat4::from_rotation_z(self.rotation.z);
        let rotation = rot_y * rot_x * rot_z;

        let mvp = mvp * position * rotation * scale;
        self.draw.draw(ctx, mvp, &self.color);
    }
}


#[derive(Default)]
pub struct ModulesObject {
    module_list: Vec<Box<dyn ModuleObject>>,
    module_list_len: usize,
}
impl ModulesObject {
    pub fn add(&mut self, module: impl ModuleObject) {
        self.module_list.push(Box::new(module));
    }
    pub(crate) fn update(&mut self, app: &App, obj: &mut Object) {
        for module in &mut self.module_list[self.module_list_len..] {
            module.ready(app, obj);
        }
        self.module_list_len = self.module_list.len();

        for module in &mut self.module_list {
            module.procces(app, obj);
        }
    }
    pub(crate) fn is_size(&self) -> bool {
        self.module_list.len() != 0
    }
}
pub trait ModuleObject: Any + Sync + Send {
    fn ready(&mut self, _app: &App, _obj: &mut Object) {}
    fn procces(&mut self, _app: &App, _obj: &mut Object) {}
}


pub trait Node: Any + Sync + Send {
    fn update(&mut self, app: &App);
    fn draw(&mut self, ctx: &mut Ctx, mvp: &Mat4);
}