smart-leds-fx 0.1.0

LED effect engine for the smart-leds ecosystem
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

use smart_leds_trait::RGB8;

use crate::effect::Effect;

#[derive(Clone, Copy, Default)]
pub struct EffectState {
    pub counter: u32,
    pub aux: u32,
}

#[derive(Clone, Copy)]
pub struct EffectConfig {
    /// Up to three colors the effect can use (primary, secondary, background).
    pub colors: [RGB8; 3],
    /// Milliseconds between effect steps.
    pub speed: u16,
}

impl Default for EffectConfig {
    fn default() -> Self {
        Self {
            colors: [
                RGB8 { r: 255, g: 0, b: 0 },
                RGB8 { r: 0, g: 0, b: 0 },
                RGB8 { r: 0, g: 0, b: 0 },
            ],
            speed: 200,
        }
    }
}

/// Per-segment rendering options.
#[derive(Clone, Copy, Default)]
pub struct SegmentOptions {
    /// Reverse the direction of directional effects.
    pub reverse: bool,
    /// Dot/block size for effects that support it (0 = 1 px, 1 = 2 px, 2 = 4 px, 3 = 8 px).
    pub size: u8,
}

pub struct Segment {
    /// First pixel index on the strip (inclusive).
    pub start: usize,
    /// Last pixel index on the strip (inclusive).
    pub stop: usize,
    pub effect: Effect,
    pub config: EffectConfig,
    pub options: SegmentOptions,
    pub state: EffectState,
    pub last_update: u64,
}

impl Segment {
    pub fn new(start: usize, stop: usize, effect: Effect) -> Self {
        Self {
            start,
            stop,
            effect,
            config: EffectConfig::default(),
            options: SegmentOptions::default(),
            state: EffectState::default(),
            last_update: 0,
        }
    }

    pub fn len(&self) -> usize {
        self.stop.saturating_sub(self.start) + 1
    }

    pub fn speed(mut self, ms: u16) -> Self {
        self.config.speed = ms;
        self
    }

    pub fn color(mut self, color: RGB8) -> Self {
        self.config.colors[0] = color;
        self
    }

    pub fn colors(mut self, colors: [RGB8; 3]) -> Self {
        self.config.colors = colors;
        self
    }

    pub fn options(mut self, options: SegmentOptions) -> Self {
        self.options = options;
        self
    }
}