bevy_cobweb_ui 0.22.2

UI framework for the bevy game engine
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 bevy::ecs::component::Mutable;
use bevy::prelude::*;

//-------------------------------------------------------------------------------------------------------------------

/// Searches for a component in the ancestors of an entity.
///
/// Does not look at the entity itself for the component.
pub fn get_ancestor_mut<T: Component<Mutability = Mutable>>(
    world: &mut World,
    entity: Entity,
) -> Option<(Entity, &mut T)>
{
    get_ancestor_mut_filtered(world, entity, |_| true)
}

//-------------------------------------------------------------------------------------------------------------------

/// Searches for a component in the ancestors of an entity.
///
/// Filters encountered components with the given callback.
///
/// Does not look at the entity itself for the component.
pub fn get_ancestor_mut_filtered<T: Component<Mutability = Mutable>>(
    world: &mut World,
    entity: Entity,
    filter: impl Fn(&T) -> bool,
) -> Option<(Entity, &mut T)>
{
    let mut current = entity;
    let mut found = false;
    while let Some(child_of) = world.get::<ChildOf>(current) {
        current = child_of.parent();
        let Some(component) = world.get::<T>(current) else { continue };
        if !(filter)(&component) {
            continue;
        }
        found = true;
        break;
    }

    // Outside loop due to borrow checker limitations.
    if found {
        let component = world.get_mut::<T>(current).unwrap();
        return Some((current, component.into_inner()));
    }

    None
}

//-------------------------------------------------------------------------------------------------------------------

/// Iterates descendants of an entity, applying the given callback.
///
/// Will stop descending if the `filter` returns `false`.
pub fn iter_descendants_filtered(
    world: &World,
    entity: Entity,
    filter: impl Fn(&World, Entity) -> bool,
    mut callback: impl FnMut(&World, Entity),
)
{
    fn iter_impl(
        world: &World,
        entity: Entity,
        filter: &impl Fn(&World, Entity) -> bool,
        callback: &mut impl FnMut(&World, Entity),
    )
    {
        // Filter
        if !(*filter)(world, entity) {
            return;
        }

        // Callback
        (*callback)(world, entity);

        // Iterate into children.
        if let Some(children) = world.get::<Children>(entity) {
            for child in children.iter() {
                iter_impl(world, child, filter, callback);
            }
        }
    }

    iter_impl(world, entity, &filter, &mut callback)
}

//-------------------------------------------------------------------------------------------------------------------

/// More performant than `.iter_descendants`, which internally allocates every time you call it.
#[derive(Resource, Default)]
pub struct IterChildren
{
    stack: Vec<Entity>,
}

impl IterChildren
{
    pub fn search<R>(
        &mut self,
        initial_entity: Entity,
        children_query: &Query<&Children>,
        search_fn: impl FnMut(Entity) -> Option<R>,
    ) -> Option<R>
    {
        self.stack.clear();
        self.stack.push(initial_entity);
        self.search_impl(children_query, search_fn)
    }

    pub fn search_descendants<R>(
        &mut self,
        initial_children: &Children,
        children_query: &Query<&Children>,
        search_fn: impl FnMut(Entity) -> Option<R>,
    ) -> Option<R>
    {
        self.stack.clear();
        self.stack.extend(initial_children);
        self.search_impl(children_query, search_fn)
    }

    pub fn search_impl<R>(
        &mut self,
        children_query: &Query<&Children>,
        mut search_fn: impl FnMut(Entity) -> Option<R>,
    ) -> Option<R>
    {
        while let Some(entity) = self.stack.pop() {
            if let Some(entry) = (search_fn)(entity) {
                return Some(entry);
            }

            if let Ok(next_children) = children_query.get(entity) {
                self.stack.extend(next_children);
            }
        }

        None
    }
}

//-------------------------------------------------------------------------------------------------------------------