tachyonfx 0.25.0

A ratatui library for creating shader-like effects in TUIs.
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

use alloc::boxed::Box;

use ratatui_core::layout::Rect;

use crate::pattern::{
    any_pattern::AnyPatternContext, AnyPattern, InstancedPattern, Pattern, PreparedPattern,
};

/// A pattern that linearly interpolates between two sub-patterns.
///
/// At each cell position the final alpha is computed as:
///
/// ```text
/// alpha = (1 - t) * pattern_a(pos) + t * pattern_b(pos)
/// ```
///
/// where `t` is the global animation progress. This produces a smooth
/// crossfade from `pattern_a` to `pattern_b` over the effect's lifetime.
///
/// # Examples
///
/// ```
/// use tachyonfx::pattern::{BlendPattern, RadialPattern, DiagonalPattern};
///
/// // crossfade from a radial wipe to a diagonal wipe
/// let pattern = BlendPattern::new(
///     RadialPattern::center(),
///     DiagonalPattern::top_left_to_bottom_right(),
/// );
/// ```
#[derive(Clone, PartialEq, Debug)]
pub struct BlendPattern {
    inner: Box<BlendPatternInner>,
}

#[derive(Clone, PartialEq, Debug)]
struct BlendPatternInner {
    pattern_a: AnyPattern,
    pattern_b: AnyPattern,
}

/// Per-frame evaluation context for [`BlendPattern`].
pub struct BlendPatternContext {
    global_alpha: f32,
    inner: Box<BlendPatternContextInner>,
}

struct BlendPatternContextInner {
    context_a: PreparedPattern<AnyPatternContext, AnyPattern>,
    context_b: PreparedPattern<AnyPatternContext, AnyPattern>,
}

impl BlendPattern {
    /// Creates a blend pattern that crossfades from `pattern_a` to `pattern_b`.
    ///
    /// At global alpha 0 the output matches `pattern_a`; at alpha 1 it
    /// matches `pattern_b`.
    pub fn new(pattern_a: impl Into<AnyPattern>, pattern_b: impl Into<AnyPattern>) -> Self {
        Self {
            inner: Box::new(BlendPatternInner {
                pattern_a: pattern_a.into(),
                pattern_b: pattern_b.into(),
            }),
        }
    }

    pub(crate) fn pattern_a(&self) -> &AnyPattern {
        &self.inner.pattern_a
    }

    pub(crate) fn pattern_b(&self) -> &AnyPattern {
        &self.inner.pattern_b
    }
}

impl Pattern for BlendPattern {
    type Context = BlendPatternContext;

    fn for_frame(self, alpha: f32, area: Rect) -> PreparedPattern<Self::Context, Self>
    where
        Self: Sized,
    {
        let context_a = self
            .inner
            .pattern_a
            .clone()
            .for_frame(alpha, area);
        let context_b = self
            .inner
            .pattern_b
            .clone()
            .for_frame(alpha, area);

        PreparedPattern {
            context: BlendPatternContext {
                global_alpha: alpha,
                inner: Box::new(BlendPatternContextInner { context_a, context_b }),
            },
            pattern: self,
        }
    }
}

impl InstancedPattern for PreparedPattern<BlendPatternContext, BlendPattern> {
    fn map_alpha(&mut self, pos: ratatui_core::layout::Position) -> f32 {
        let inner = &mut *self.context.inner;
        let alpha_a = inner.context_a.map_alpha(pos);
        let alpha_b = inner.context_b.map_alpha(pos);

        let global_alpha = self.context.global_alpha;
        (1.0 - global_alpha) * alpha_a + global_alpha * alpha_b
    }
}