hai_core 0.7.0

Core implementation of Hai game engine, and general 2D rendering library using WebGPU as well.
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

use hai_pal::sync::RwLock;
use std::sync::Arc;

use crate::traits::Node;

/// walk through all node-like ones from top to bottom,
/// due that the depth should not big, recursive is acceptable
pub fn walk_nodes_top_bottom<T>(root_node: &(dyn Node), func: &mut T) -> bool
where
    // child, arr, parent_node  -> should_end
    T: FnMut(Arc<RwLock<dyn Node>>, &(dyn Node)) -> bool,
{
    let children = root_node.base().children();
    for child in children.iter() {
        let should_end = func(child.clone(), root_node);

        if should_end {
            return true;
        }

        let child = child.read();

        if !child.base().children().is_empty() {
            let should_end = walk_nodes_top_bottom(&*child, func);
            if should_end {
                return true;
            }
        }
    }
    false
}

/// walk through all node-like ones from bottom to top,
/// due that the depth should not big, recursive is acceptable
pub fn walk_nodes_bottom_top<T>(
    root_node: &(dyn Node),
    func: &mut T,
    current_parent_ids: &[u32],
    only_interactive: bool,
) -> bool
where
    // child, parent_node, parent_ids  -> should_end
    T: FnMut(Arc<RwLock<dyn Node>>, &(dyn Node), &[u32]) -> bool,
{
    let children = root_node.base().children();
    for child in children.iter().rev() {
        {
            let child = child.read();

            // skip non-interactive nodes
            if !child.base().interactive() && only_interactive {
                continue;
            }

            if !child.base().children().is_empty() {
                let parent_ids = current_parent_ids
                    .iter()
                    .chain([child.base().id()])
                    .copied()
                    .collect::<Vec<_>>();

                let should_end =
                    walk_nodes_bottom_top(&*child, func, &parent_ids, only_interactive);
                if should_end {
                    return true;
                }
            }
        }

        let should_end = func(child.clone(), root_node, current_parent_ids);
        if should_end {
            return true;
        }
    }
    false
}