gizmo-engine 0.1.2

A custom ECS and physics engine aimed for realistic simulations.
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

pub struct TransformSyncSystem;

impl gizmo_core::system::System for TransformSyncSystem {
    fn access_info(&self) -> gizmo_core::system::AccessInfo {
        let mut info = gizmo_core::system::AccessInfo::new();
        // Since we borrow components, we can mark it as exclusive to be safe, or specify component access.
        // For simplicity and safety during hierarchy traversal, we'll make it exclusive.
        info.is_exclusive = true;
        info
    }

    fn run(&mut self, world: &gizmo_core::world::World, _dt: f32) {
        let transforms = world.borrow_mut::<crate::physics::Transform>();
        for (_, trans) in transforms.iter_mut() {
            trans.update_local_matrix();
        }
    }
}

pub struct TransformPropagateSystem;

impl gizmo_core::system::System for TransformPropagateSystem {
    fn access_info(&self) -> gizmo_core::system::AccessInfo {
        let mut info = gizmo_core::system::AccessInfo::new();
        info.is_exclusive = true; // Safe fallback for complex queries
        info
    }

    fn run(&mut self, world: &gizmo_core::world::World, _dt: f32) {
        let locals = world.borrow::<crate::physics::Transform>();
        let mut globals = world.borrow_mut::<crate::physics::GlobalTransform>();
        let parents = world.borrow::<gizmo_core::component::Parent>();
        let children_storage = world.borrow::<gizmo_core::component::Children>();

        let mut queue = Vec::new();

        // 1. Kökleri (Root) işle ve GlobalTransform'larını kendi yerellerine eşitle
        for (id, local) in locals.iter() {
            if parents.get(id).is_none() {
                if let Some(global) = globals.get_mut(id) {
                    global.matrix = local.local_matrix;

                    // Eğer çocukları varsa kuyruğa ekle
                    if let Some(children) = children_storage.get(id) {
                        for &child_id in &children.0 {
                            queue.push((global.matrix, child_id));
                        }
                    }
                }
            }
        }

        // 2. Çocukları hiyerarşik olarak BFS ile işle
        let mut head = 0;
        while head < queue.len() {
            let (parent_matrix, current_id) = queue[head];
            head += 1;

            if let Some(local) = locals.get(current_id) {
                if let Some(global) = globals.get_mut(current_id) {
                    global.matrix = parent_matrix * local.local_matrix;

                    if let Some(children) = children_storage.get(current_id) {
                        for &child_id in &children.0 {
                            queue.push((global.matrix, child_id));
                        }
                    }
                }
            }
        }
    }
}