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

//! Math utilities with no_std compatibility
//!
//! This module provides math functions that work in both std and no_std environments.
//! Functions where micromath outperforms std (sqrt, round, floor, ceil) always use
//! micromath. Functions where std is faster (powf) use cfg-gated implementations.

use core::f32::consts::TAU;

/// Parabolic sine approximation. Input is in radians.
#[inline(always)]
pub fn parabolic_sin(t: f32) -> f32 {
    wave_sin(t * (1.0 / TAU))
}

/// Parabolic cosine approximation. Input is in radians.
#[inline(always)]
pub fn parabolic_cos(t: f32) -> f32 {
    wave_sin(t * (1.0 / TAU) + 0.25)
}

/// Fast, branchless sine approximation using parabolic segments.
///
/// Input `t` is in normalized cycles where `1.0` equals one full period.
/// Values beyond `1.0` wrap naturally, so `t` can increase continuously
/// to produce repeating oscillations (e.g., `2.5` is equivalent to `0.5`).
///
/// Output ranges from `-1.0` to `1.0`. The shape closely follows a true
/// sine wave but with slightly flattened peaks.
#[inline(always)]
pub fn wave_sin(t: f32) -> f32 {
    let f = micromath::F32Ext::fract(t);
    let x = if f < 0.0 { f + 1.0 } else { f };
    let phase: f32 = 1.0 - 2.0 * x;
    4.0 * phase * (1.0 - micromath::F32Ext::abs(phase))
}

/// Fast, branchless cosine approximation using parabolic segments.
///
/// Input `t` is in normalized cycles where `1.0` equals one full period.
/// Values beyond `1.0` wrap naturally. Output ranges from `-1.0` to `1.0`.
#[inline(always)]
pub fn wave_cos(t: f32) -> f32 {
    wave_sin(t + 0.25)
}

/// Square root function using micromath (faster than std)
#[inline]
pub(crate) fn sqrt(x: f32) -> f32 {
    micromath::F32Ext::sqrt(x)
}

/// Sine function that works in both std and no_std environments
#[inline]
pub(crate) fn sin(x: f32) -> f32 {
    parabolic_sin(x)
}

/// Cosine function that works in both std and no_std environments
#[inline]
pub(crate) fn cos(x: f32) -> f32 {
    parabolic_cos(x)
}

/// Power function that works in both std and no_std environments
#[cfg(feature = "std")]
#[inline]
pub(crate) fn powf(base: f32, exp: f32) -> f32 {
    base.powf(exp)
}

/// Power function that works in both std and no_std environments
#[cfg(not(feature = "std"))]
#[inline]
pub(crate) fn powf(base: f32, exp: f32) -> f32 {
    use micromath::F32Ext;
    base.powf(exp)
}

/// Integer power function that works in both std and no_std environments
#[cfg(feature = "std")]
#[inline]
pub(crate) fn powi(base: f32, exp: i32) -> f32 {
    base.powi(exp)
}

/// Integer power function that works in both std and no_std environments
#[cfg(not(feature = "std"))]
#[inline]
pub(crate) fn powi(base: f32, exp: i32) -> f32 {
    use micromath::F32Ext;
    base.powi(exp)
}

/// Round function using micromath (faster than std)
#[inline]
pub(crate) fn round(x: f32) -> f32 {
    micromath::F32Ext::round(x)
}

/// Floor function using micromath (faster than std)
#[inline]
pub(crate) fn floor(x: f32) -> f32 {
    micromath::F32Ext::floor(x)
}

/// Ceiling function using micromath (faster than std)
#[inline]
pub(crate) fn ceil(x: f32) -> f32 {
    micromath::F32Ext::ceil(x)
}