ry-anim

Animation module for Ry-Dit - 12 Disney Principles + Visual Effects + Science Animations

Overview

ry-anim is a comprehensive animation library implementing the 12 principles of Disney animation, visual effects (bloom, chromatic aberration, motion blur), optical illusions, science-based animations, and sprite animation systems.

Designed for game engines and creative coding, it provides 58+ tested functions covering easing, squash & stretch, anticipation, follow-through, arcs, secondary action, timing, exaggeration, and more.

Features

🎨 12 Disney Animation Principles

✨ Visual Effects

• Bloom - Diffuse glow on bright areas
• Chromatic Aberration - RGB channel separation
• Motion Blur - Directional blur for movement
• Neon Glow - Configurable neon effect
• Particle Trails - Trailing particle effects
• Morph Shapes - Smooth shape transitions

🔬 Science Animations

• Wave Interference - Physics wave patterns
• Pendulum Waves - Synchronized pendulum motion
• Cell Division - Biological mitosis animation
• Chemical Crystallization - Crystal formation
• L-System Trees - Procedural plant growth
• Tusi Couple - Historical mathematical mechanism
• Walk Cycle - Fauna walking animation
• Flight Pattern - Bird flapping animation

🎭 Optical Illusions

• Rotating Snakes - Circular motion illusion
• Café Wall - Parallel lines appear tilted
• Troxler Fading - Disappearance by fixation
• Pulsing Star - Pulsating star effect
• Zöllner Effect - Non-parallel line illusion
• Motion-Induced Blindness - Disappearing dots

🎬 Sprite Animation System

• Frame Animation - Frame-by-frame sprite playback
• Sprite Sheet Parser - Parse sprite sheet images
• Animation State Machine - Manage animation states
• Animation Blending - Smooth transitions between states
• Sprite Events - Trigger events at specific frames
• Sprite Flip - Horizontal/vertical sprite flipping

Installation

[dependencies]
ry-anim = "0.7.34"
ry-core = "0.8.2"
serde_json = "1.0"
serde = { version = "1.0", features = ["derive"] }

Quick Start

Easing Functions

use ry_anim::AnimModule;
use ry_core::RyditModule;
use serde_json::json;

let anim = AnimModule;

// Quadratic ease in (slow start)
let eased = anim.execute("ease_in", json!([0.5]))?;
assert_eq!(eased.as_f64().unwrap(), 0.25); // 0.5²

// Quadratic ease out (slow end)
let eased = anim.execute("ease_out", json!([0.5]))?;
assert_eq!(eased.as_f64().unwrap(), 0.75); // 0.5 * (2.0 - 0.5)

// Ease in-out (S-curve)
let eased = anim.execute("ease_in_out", json!([0.5]))?;
assert_eq!(eased.as_f64().unwrap(), 0.5);

Squash & Stretch

// Impact squash (compress vertically, expand horizontally)
let squash = anim.execute("squash", json!([2.0]))?;
// Returns: [2.0, 0.5] - 2x wide, 0.5x tall

// Stretch (expand vertically, compress horizontally)
let stretch = anim.execute("stretch", json!([1.5]))?;
// Returns: [0.67, 1.5] - 0.67x wide, 1.5x tall

Anticipation

// Move from 100 to 200 with 20 units of anticipation
let anticipate = anim.execute("anticipate", json!([100.0, 200.0, 20.0]))?;
// Returns: 80.0 (moves back 20 before going forward)

Arc Path

// Curved trajectory from (0, 0) to (10, 0) with curvature 5
let arc = anim.execute("arc_path", json!([0.0, 0.0, 10.0, 0.0, 5.0, 0.5]))?;
// Returns: [x, y] position at t=0.5 on the arc

Keyframe Timing

// Interpolate between keyframes: [(frame, value), ...]
let keyframes = json!([[0.0, 0.0], [30.0, 100.0], [60.0, 0.0]]);
let value = anim.execute("timing", json!([keyframes, 15.0]))?;
// Returns: 50.0 (halfway to 100 at frame 15)

Sprite Animation

// Frame-by-frame animation
let frame = anim.execute("frame_animation", json!([0, 10, 5]))?;
// Current frame: 5 of 10 total frames

// Flip sprite horizontally
let flipped = anim.execute("sprite_flip", json!(["horizontal"]))?;
// Returns flip direction

API Reference

Core Module

All functions are accessed through the AnimModule struct implementing RyditModule:

pub struct AnimModule;

impl RyditModule for AnimModule {
    fn name(&self) -> &'static str { "anim" }
    fn version(&self) -> &'static str { "0.12.0" }
    fn register(&self) -> HashMap<&'static str, &'static str>;
    fn execute(&self, command: &str, params: Value) -> ModuleResult;
}

Available Commands

Easing

Deformation

Motion

Visual Effects

Science

Optical Illusions

Sprites

Performance

• Zero allocations in easing functions (pure math)
• JSON-based command interface for scripting flexibility
• 58 unit tests ensuring correctness across all functions
• 2900+ lines of production-ready animation code

Dependencies

Examples

Ball Bounce Animation

use ry_anim::AnimModule;
use ry_core::RyditModule;
use serde_json::json;

let anim = AnimModule;

// Simulate ball falling and bouncing
let mut y = 0.0;
let mut velocity = 0.0;
let gravity = 9.8;

for frame in 0..120 {
    let t = frame as f64 / 60.0;
    
    // Apply gravity with ease
    velocity += anim.execute("ease_in", json!([gravity * 0.016]))?
        .as_f64().unwrap();
    y += velocity;
    
    // Bounce with squash
    if y >= 100.0 {
        y = 100.0;
        velocity *= -0.7; // Damping
        let squash = anim.execute("squash", json!([1.3]))?;
        println!("Bounce! Squash factor: {:?}", squash);
    }
}

Smooth Camera Follow

// Camera follows player with anticipation and arc motion
let camera_pos = 50.0;
let player_pos = 150.0;

// Anticipate movement
let anticipate = anim.execute("anticipate", 
    json!([camera_pos, player_pos, 10.0]))?;

// Smooth arc path
let arc = anim.execute("arc_path", 
    json!([camera_pos, 0.0, player_pos, 0.0, 20.0, 0.5]))?;

println!("Camera moves from {} along arc {:?}", camera_pos, arc);

Walk Cycle Animation

// 4-phase walk cycle
for phase in 0..100 {
    let t = phase as f64 / 100.0;
    let walk = anim.execute("walk_cycle", json!([t, 1.0]))?;
    // Apply walk animation to character
}

Roadmap

• Cubic and quartic easing curves
• 3D bone animation system
• Inverse kinematics
• Morph targets
• Animation curves editor
• GPU-accelerated particle systems

Contributing

Contributions are welcome! This crate is part of the Ry-Dit game engine project.

• Repository: https://github.com/lapumlbb18-blip/Ry-dit
• Issues: https://github.com/lapumlbb18-blip/Ry-dit/issues
• Pull Requests: Welcome!

Please read CONTRIBUTING.md for guidelines.

License

MIT License - See LICENSE for details.

Related Crates

ry-anim - Bringing Disney magic to Rust game development 🎬✨

58 tests · 2900+ lines · 12 Disney principles · 6 optical illusions · 8 science animations