bevy_feronia 0.8.2

Foliage/grass scattering tools and wind simulation shaders/materials that prioritize visual fidelity/artistic freedom, a declarative api and modularity.
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

use crate::prelude::*;
use bevy_ecs::prelude::*;
use bevy_ecs::system::Commands;
use bevy_state::state::NextState;
#[cfg(feature = "trace")]
use tracing::debug;

pub fn check_unprocessed_items(
    mut cmd: Commands,
    q_layer: Query<
        (Entity, &Children, Option<&Name>),
        (Without<ScatterLayerProcessed>, With<ScatterLayer>),
    >,
    q_unprocessed: Query<Entity, Without<ScatterLayerChildProcessed>>,
) {
    for (layer, children, _name) in q_layer
        .iter()
        .filter(|(_, children, _)| !children.is_empty())
    {
        if children
            .iter()
            .map(|e| q_unprocessed.get(e))
            .any(|r| r.is_ok())
        {
            #[cfg(feature = "trace")]
            debug!(
                "ScatterLayer {} {layer} has unprocessed children.",
                _name.cloned().unwrap_or_default()
            );
            continue;
        }

        #[cfg(feature = "trace")]
        debug!(
            "ScatterLayer {} {layer} processed.",
            _name.cloned().unwrap_or_default()
        );

        cmd.entity(layer).insert(ScatterLayerProcessed);
    }
}

pub fn check_unprocessed_layers(
    mut cmd: Commands,
    q_roots: Query<(Entity, &ScatterRoot), Without<ScatterRootProcessed>>,
    q_unprocessed_layers: Query<&Children, (Without<ScatterLayerProcessed>, With<ScatterLayer>)>,
) {
    for (root, children) in q_roots.iter().filter(|(_, children)| !children.is_empty()) {
        #[cfg(feature = "trace")]
        debug!("Collecting ScatterAssets in root {:?}...", root);

        if children
            .iter()
            .map(|e| q_unprocessed_layers.get(e))
            .any(|r| r.is_ok())
        {
            #[cfg(feature = "trace")]
            debug!("ScatterRoot {root} has unprocessed layers.");
            continue;
        }

        #[cfg(feature = "trace")]
        debug!("ScatterRoot {root} is processed.");

        cmd.entity(root).insert(ScatterRootProcessed);
    }
}

pub fn check_unprocessed_root(
    q_unprocessed_roots: Query<(Entity, &ScatterRoot), Without<ScatterRootProcessed>>,
    mut ns_scatter: ResMut<NextState<ScatterState>>,
) {
    if !q_unprocessed_roots.is_empty() {
        return;
    };

    #[cfg(feature = "trace")]
    debug!("Setting ScatterState::Ready.");
    ns_scatter.set(ScatterState::Ready);
}