nightshade 0.14.0

A cross-platform data-oriented game engine.
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

use crate::ecs::ui::components::{
    ThemeEffect, ThemeShadow, UiNodeContent, UiNodeEffect, UiNodeShadow,
};
use crate::ecs::ui::theme::UiTheme;
use crate::ecs::world::World;

fn resolve_shadow(theme: &UiTheme, role: ThemeShadow) -> Option<UiNodeShadow> {
    Some(match role {
        ThemeShadow::PanelShadow => theme.panel_shadow,
        ThemeShadow::ButtonShadow => theme.button_shadow,
        ThemeShadow::ButtonShadowHover => theme.button_shadow_hover,
        ThemeShadow::ButtonShadowPressed => theme.button_shadow_pressed,
        ThemeShadow::ModalShadow => theme.modal_shadow,
        ThemeShadow::FocusGlow => theme.focus_glow?,
    })
}

fn resolve_effect(theme: &UiTheme, role: ThemeEffect) -> UiNodeEffect {
    let preset = match role {
        ThemeEffect::PanelEffect => theme.panel_effect,
        ThemeEffect::ButtonEffect => theme.button_effect,
        ThemeEffect::InputEffect => theme.input_effect,
    };
    let (kind, params) = preset.encode();
    UiNodeEffect { kind, params }
}

pub fn ui_theme_transition_tick_system(world: &mut World) {
    if !world.resources.retained_ui.enabled {
        return;
    }
    let delta_time = world.resources.window.timing.delta_time;
    world
        .resources
        .retained_ui
        .theme_state
        .tick_transition(delta_time);
}

pub fn ui_theme_apply_system(world: &mut World) {
    if !world.resources.retained_ui.enabled {
        return;
    }

    let generation = world.resources.retained_ui.theme_state.generation;
    if generation
        == world
            .resources
            .retained_ui
            .theme_state
            .last_applied_generation
    {
        return;
    }
    world
        .resources
        .retained_ui
        .theme_state
        .last_applied_generation = generation;

    let theme = world
        .resources
        .retained_ui
        .theme_state
        .active_theme()
        .clone();

    let entities: Vec<freecs::Entity> = world
        .ui
        .query_entities(crate::ecs::world::UI_THEME_BINDING)
        .collect();

    for entity in entities {
        let binding = match world.ui.get_ui_theme_binding(entity) {
            Some(binding) => *binding,
            None => continue,
        };

        if let Some(node_color) = world.ui.get_ui_node_color_mut(entity) {
            for (state_index, role) in binding.color_roles.iter().enumerate() {
                if let Some(role) = role {
                    node_color.colors[state_index] = Some(role.resolve(&theme));
                }
            }
        }

        if let Some(border_role) = binding.border_color_role
            && let Some(content) = world.ui.get_ui_node_content_mut(entity)
            && let UiNodeContent::Rect { border_color, .. } = content
        {
            *border_color = border_role.resolve(&theme);
        }

        let has_any_shadow = binding.shadow_roles.iter().any(|r| r.is_some());
        if has_any_shadow {
            let mut state_shadows = [None; crate::ecs::ui::state::STATE_COUNT];
            for (state_index, role) in binding.shadow_roles.iter().enumerate() {
                if let Some(role) = role {
                    state_shadows[state_index] = resolve_shadow(&theme, *role);
                }
            }
            world
                .ui
                .add_components(entity, crate::ecs::world::UI_NODE_SHADOW_STATES);
            if let Some(slot) = world.ui.get_ui_node_shadow_states_mut(entity) {
                slot.shadows = state_shadows;
            }
            let base_shadow = state_shadows[0].unwrap_or_default();
            world
                .ui
                .add_components(entity, crate::ecs::world::UI_NODE_SHADOW);
            if let Some(slot) = world.ui.get_ui_node_shadow_mut(entity) {
                *slot = base_shadow;
            }
        }

        if let Some(role) = binding.effect_role {
            let effect = resolve_effect(&theme, role);
            world
                .ui
                .add_components(entity, crate::ecs::world::UI_NODE_EFFECT);
            if let Some(slot) = world.ui.get_ui_node_effect_mut(entity) {
                *slot = effect;
            }
        }
    }
}