bevy_mistUI 0.1.2

Procedural mist and smoke-ring borders for Bevy UI.
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

use bevy::prelude::*;

/// Component that turns a UI node's border into a procedural smoke ring.
#[derive(Component, Clone, Reflect, Debug, PartialEq)]
pub struct SmokeBorder {
    /// Base color of the smoke.
    pub color: Color,
    /// Width of the smoke ring relative to the element size.
    pub thickness: f32,
    /// Overall brightness/opacity multiplier.
    pub intensity: f32,
    /// Speed of the smoke flow animation.
    pub flow_speed: f32,
    /// Scale of the noise texture (affects detail density).
    pub noise_scale: f32,
    /// Softness of the smoke edges.
    pub softness: f32,
    /// Strength of the rhythmic pulsing effect.
    pub pulse_strength: f32,
    /// Color of the pulsing glow.
    pub pulse_color: Color,
}

impl Default for SmokeBorder {
    fn default() -> Self {
        Self {
            color: Color::srgb(0.9, 0.95, 1.0),
            thickness: 0.45,
            intensity: 1.8,
            flow_speed: 1.0,
            noise_scale: 28.0,
            softness: 0.15,
            pulse_strength: 0.45,
            pulse_color: Color::srgb(0.6, 0.8, 1.0),
        }
    }
}

impl SmokeBorder {
    pub fn new() -> Self {
        Self::default()
    }

    pub fn with_color(mut self, color: Color) -> Self {
        self.color = color;
        self
    }

    pub fn with_thickness(mut self, thickness: f32) -> Self {
        self.thickness = thickness;
        self
    }

    pub fn with_intensity(mut self, intensity: f32) -> Self {
        self.intensity = intensity;
        self
    }

    pub fn neon_tube(primary: Color, secondary: Color, _seed: u32) -> Self {
        Self {
            color: primary,
            pulse_color: secondary,
            intensity: 1.5,
            thickness: 0.18,
            softness: 0.2,
            flow_speed: 1.0,
            noise_scale: 40.0,
            pulse_strength: 0.6,
        }
    }

    pub fn gaseous_idle(_seed: u64) -> Self {
        Self {
            color: Color::srgb(1.0, 1.0, 1.0),
            pulse_color: Color::srgb(0.92, 0.96, 1.0),
            intensity: 2.6,
            thickness: 0.1,
            softness: 0.4,
            flow_speed: 0.4,
            noise_scale: 36.0,
            pulse_strength: 0.15,
        }
    }

    pub fn disabled() -> Self {
        Self {
            intensity: 0.0,
            ..Default::default()
        }
    }

    pub fn particle_border(seed: u64) -> Self {
        Self::gaseous_thick_border(seed)
    }

    pub fn gaseous_thick_border(seed: u64) -> Self {
        let mut border = Self::gaseous_idle(seed);
        border.thickness = 0.35;
        border.intensity = 5.2;
        border.softness = 0.12;
        border.noise_scale = 58.0;
        border
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn smoke_border_presets_keep_expected_ordering() {
        let idle = SmokeBorder::gaseous_idle(0);
        let thick = SmokeBorder::gaseous_thick_border(1);

        assert!(idle.intensity > 0.0);
        assert!(idle.thickness > 0.0);
        assert!(thick.intensity > idle.intensity);
        assert!(thick.thickness > idle.thickness);
        assert_eq!(SmokeBorder::disabled().intensity, 0.0);
    }
}