🔮 :: Slinky - Concentric Ellipses

🧩 Pseudo-code 구조 설계

• NUM_RINGS: 동심원의 개수.
• ELLIPSE_RATIO: 이심률을 통해 원형 → 타원형 변화 제어.
• DEPTH_SCALE: 원이 안쪽으로 갈수록 점점 작아지는 비율.
• COLOR_VARIATION: 각 원의 hue를 랜덤하게 조절.
• LINE_WEIGHT: 두께 조정으로 깊이감 보강.
• Ring: 각 원의 반지름, 색상, 이심률 정보를 가짐.
• Model: 전체 ring 집합을 관리하고 view에서 반복 렌더링.
• OUTER_WEIGHT → INNER_WEIGHT
  : 가장 바깥쪽 원은 두껍고, 안쪽으로 갈수록 선이 얇아짐.

📝 Rust Code

use nannou::prelude::*;

const NUM_RINGS: usize = 100;
const ELLIPSE_RATIO: f32 = 1.0;
const COLOR_VARIATION: f32 = 0.2;
const DEPTH_SCALE: f32 = 0.98;
const BASE_RADIUS: f32 = 800.0;
const HUE_BASE: f32 = 0.5;
const FOLLOW_SPEED: f32 = 0.45;

const OUTER_WEIGHT: f32 = 15.0; // 가장 바깥쪽 원의 두께
const INNER_WEIGHT: f32 = 1.0; // 가장 안쪽 원의 두께

// ----------------------------------------------------
// 보조 함수: 선형 보간 (lerp)
// ----------------------------------------------------
fn lerp(a: f32, b: f32, t: f32) -> f32 {
    a + (b - a) * t
}

// ----------------------------------------------------
// 구조체 정의
// ----------------------------------------------------
struct Model {
    rings: Vec<Ring>,
}

struct Ring {
    radius: f32,
    color: Hsla,
    eccentricity: f32,
    position: Vec2,
    weight: f32,
}

// ----------------------------------------------------
// impl: Ring
// ----------------------------------------------------
impl Ring {
    fn new(radius: f32, color: Hsla, eccentricity: f32, position: Vec2, weight: f32) -> Self {
        Self {
            radius,
            color,
            eccentricity,
            position,
            weight,
        }
    }

    fn follow(&mut self, target: Vec2, lerp_amount: f32) {
        self.position = self.position + (target - self.position) * lerp_amount;
    }
}

// ----------------------------------------------------
// impl: Model
// ----------------------------------------------------
impl Model {
    fn new(app: &App) -> Self {
        app.new_window()
            .size(1024, 1024)
            .title("Concentric Color Ellipses Follow Mouse")
            .build()
            .unwrap();

        let mut rings = Vec::new();

        // NUM_RINGS이 적어도 2개 이상일 것을 가정하되, 방어적으로 처리
        let denom = if NUM_RINGS > 1 { (NUM_RINGS - 1) as f32 } else { 1.0 };

        for i in 0..NUM_RINGS {
            let t = (i as f32) / denom; // 0.0 (outer) -> 1.0 (inner)
            // 선 두께를 보간 (바깥쪽에서 안쪽으로)
            let weight = lerp(OUTER_WEIGHT, INNER_WEIGHT, t);

            let radius = BASE_RADIUS * DEPTH_SCALE.powf(i as f32);
            let hue = (HUE_BASE + random_f32() * COLOR_VARIATION) % 1.0;
            let color = hsla(hue, 0.8, 0.5, 1.0);

            rings.push(Ring::new(radius, color, ELLIPSE_RATIO, vec2(0.0, 0.0), weight));
        }

        Self { rings }
    }

    fn update(&mut self, app: &App) {
        let mouse = app.mouse.position();

        // 가장 안쪽(가장 작은) 원이 마우스를 따라가도록: rings의 마지막 요소를 사용
        if let Some(last) = self.rings.last_mut() {
            last.follow(mouse, FOLLOW_SPEED);
        }

        // 그 외 원들은 내부 쪽(더 작은 반지름)에 있는 원을 따라가도록 보간
        // 안전하게 len() 검사
        if self.rings.len() >= 2 {
            for i in (0..self.rings.len() - 1).rev() {
                let target_pos = self.rings[i + 1].position;
                // 바깥쪽으로 갈수록 반응을 조금 느리게 만들어 자연스럽게 보이도록 조정
                let lerp_amt = FOLLOW_SPEED * 0.8;
                self.rings[i].follow(target_pos, lerp_amt);
            }
        }
    }

    fn view(&self, app: &App, frame: Frame) {
        let draw = app.draw();
        draw.background().color(hsla(0.0, 0.0, 0.02, 1.0));

        for ring in &self.rings {
            draw.ellipse()
                .x_y(ring.position.x, ring.position.y)
                .w(ring.radius)
                .h(ring.radius * ring.eccentricity)
                .no_fill()
                .stroke(ring.color)
                .stroke_weight(ring.weight);
        }

        draw.to_frame(app, &frame).unwrap();
    }
}

// ----------------------------------------------------
// main() & 콜백들
// ----------------------------------------------------
fn main() {
    nannou::app(model).update(update).view(view).run();
}

fn model(app: &App) -> Model {
    Model::new(app)
}

fn update(app: &App, model: &mut Model, _update: Update) {
    model.update(app);
}

fn view(app: &App, model: &Model, frame: Frame) {
    model.view(app, frame);
}