Rust动画过渡效果库simple-easing使用指南

simple-easing是一个轻量级的Rust库，提供了多种缓动函数(easing functions)来实现平滑的动画过渡效果。这些函数可以帮助你在UI动画、游戏开发或其他需要平滑过渡的场景中创建更自然的运动效果。

安装

在Cargo.toml中添加依赖：

[dependencies]
simple-easing = "0.2"

基本用法

simple-easing提供了多种缓动函数，每种都有三种变体：ease_in、ease_out和ease_in_out。

示例：基本缓动函数使用

use simple_easing::{quadratic, cubic, sine};

fn main() {
    // 线性插值示例
    let t = 0.5; // 时间进度，范围[0.0, 1.0]
    let value = sine::ease_in_out(t);
    println!("Sine ease-in-out at t=0.5: {}", value);
    
    // 计算动画过程中的值
    let start = 0.0;
    let end = 100.0;
    let current_value = start + (end - start) * cubic::ease_out(t);
    println!("Current animated value: {}", current_value);
}

支持的缓动函数类型

库中包含了以下缓动函数：

1. 线性(linear)
2. 二次(quadratic)
3. 三次(cubic)
4. 四次(quartic)
5. 五次(quintic)
6. 正弦(sine)
7. 圆形(circular)
8. 指数(exponential)
9. 弹性(elastic)
10. 反弹(back)
11. 弹跳(bounce)

示例：多种缓动函数比较

use simple_easing::{quadratic, cubic, sine, bounce};

fn compare_easings(t: f32) {
    println!("t={}", t);
    println!("Quadratic ease-in: {}", quadratic::ease_in(t));
    println!("Cubic ease-out: {}", cubic::ease_out(t));
    println!("Sine ease-in-out: {}", sine::ease_in_out(t));
    println!("Bounce ease-out: {}", bounce::ease_out(t));
}

fn main() {
    compare_easings(0.25);
    compare_easings(0.5);
    compare_easings(0.75);
}

实际动画应用示例

下面是一个使用simple-easing实现简单动画循环的例子：

use simple_easing::cubic;
use std::thread;
use std::time::{Duration, Instant};

struct Animation {
    start_time: Instant,
    duration: f32,
    start_value: f32,
    end_value: f32,
}

impl Animation {
    fn new(duration_secs: f32, start: f32, end: f32) -> Self {
        Animation {
            start_time: Instant::now(),
            duration: duration_secs,
            start_value: start,
            end_value: end,
        }
    }
    
    fn current_value(&self) -> f32 {
        let elapsed = self.start_time.elapsed().as_secs_f32();
        let t = (elapsed / self.duration).min(1.0); // 确保不超过1.0
        
        // 使用缓动函数计算当前值
        self.start_value + (self.end_value - self.start_value) * cubic::ease_in_out(t)
    }
    
    fn is_finished(&self) -> bool {
        self.start_time.elapsed().as_secs_f32() >= self.duration
    }
}

fn main() {
    let mut anim = Animation::new(2.0, 0.0, 100.0);
    
    while !anim.is_finished() {
        println!("Current value: {:.2}", anim.current_value());
        thread::sleep(Duration::from_millis(16)); // ~60fps
    }
    
    println!("Animation finished!");
}

自定义缓动函数

虽然simple-easing提供了多种预设函数，但你也可以轻松创建自己的缓动函数：

// 自定义线性缓动函数
fn linear_ease(t: f32) -> f32 {
    t
}

// 自定义"强弹性"缓动函数
fn strong_elastic_ease(t: f32) -> f32 {
    if t == 0.0 || t == 1.0 {
        return t;
    }
    
    let p = 0.3;
    let s = p / 4.0;
    let post_fix = 2.0_f32.powf(10.0 * (t - 1.0));
    
    -(( (t - 1.0) * 2.0 * std::f32::consts::PI / p ).sin() * post_fix)
}

fn main() {
    for t in 0..=10 {
        let t = t as f32 * 0.1;
        println!("t={:.1}, custom={:.4}", t, strong_elastic_ease(t));
    }
}

性能考虑

simple-easing是一个非常轻量级的库，所有函数都是纯数学计算，没有分配或系统调用，因此性能极高，适合在游戏循环或动画系统中频繁调用。

完整示例代码

下面是一个结合多种缓动函数的完整动画示例，展示如何创建一个简单的动画系统：

use simple_easing::{quadratic, cubic, sine, bounce, exponential};
use std::thread;
use std::time::{Duration, Instant};

// 动画状态枚举
enum AnimationState {
    Running,
    Paused,
    Finished,
}

// 动画结构体
struct Animation {
    start_time: Instant,
    pause_time: Option<Instant>,
    duration: f32,
    start_value: f32,
    end_value: f32,
    state: AnimationState,
    easing_fn: fn(f32) -> f32, // 缓动函数指针
}

impl Animation {
    fn new(duration_secs: f32, start: f32, end: f32, easing_fn: fn(f32) -> f32) -> Self {
        Animation {
            start_time: Instant::now(),
            pause_time: None,
            duration: duration_secs,
            start_value: start,
            end_value: end,
            state: AnimationState::Running,
            easing_fn,
        }
    }
    
    // 暂停动画
    fn pause(&mut self) {
        if let AnimationState::Running = self.state {
            self.pause_time = Some(Instant::now());
            self.state = AnimationState::Paused;
        }
    }
    
    // 恢复动画
    fn resume(&mut self) {
        if let AnimationState::Paused = self.state {
            if let Some(pause_time) = self.pause_time {
                let pause_duration = pause_time - self.start_time;
                self.start_time = Instant::now() - pause_duration;
                self.pause_time = None;
                self.state = AnimationState::Running;
            }
        }
    }
    
    // 获取当前值
    fn current_value(&self) -> f32 {
        let elapsed = match self.state {
            AnimationState::Running => self.start_time.elapsed().as_secs_f32(),
            AnimationState::Paused => self.pause_time.unwrap().duration_since(self.start_time).as_secs_f32(),
            AnimationState::Finished => self.duration,
        };
        
        let t = (elapsed / self.duration).min(1.0);
        let eased_t = (self.easing_fn)(t);
        
        self.start_value + (self.end_value - self.start_value) * eased_t
    }
    
    // 检查动画是否完成
    fn update_state(&mut self) {
        if let AnimationState::Running = self.state {
            if self.start_time.elapsed().as_secs_f32() >= self.duration {
                self.state = AnimationState::Finished;
            }
        }
    }
    
    fn is_finished(&self) -> bool {
        matches!(self.state, AnimationState::Finished)
    }
}

fn main() {
    // 创建多个使用不同缓动函数的动画
    let mut animations = vec![
        Animation::new(3.0, 0.0, 100.0, quadratic::ease_in_out),
        Animation::new(2.5, 0.0, 200.0, cubic::ease_out),
        Animation::new(4.0, 100.0, 0.0, bounce::ease_out),
        Animation::new(3.5, 0.0, 150.0, exponential::ease_in),
    ];
    
    // 模拟暂停/恢复
    thread::sleep(Duration::from_secs_f32(1.0));
    animations[0].pause();
    thread::sleep(Duration::from_secs_f32(0.5));
    animations[0].resume();
    
    // 主循环
    while animations.iter().any(|a| !a.is_finished()) {
        for (i, anim) in animations.iter_mut().enumerate() {
            anim.update_state();
            if !anim.is_finished() {
                println!("Anim {}: {:.2}", i, anim.current_value());
            }
        }
        println!("---");
        thread::sleep(Duration::from_millis(100)); // 10fps
    }
    
    println!("All animations finished!");
}

总结

simple-easing为Rust开发者提供了简单易用的缓动函数集合，可以帮助你快速实现各种平滑动画效果。无论是UI元素动画、游戏对象移动还是其他需要渐进变化的场景，这个库都能提供很好的支持。