🔮 :: Flower Dance

• 창 크기에 맞춰 반지름/점 크기를 스케일링
• 여러 레이어(링)를 서로 다른 속도/진폭으로 움직이게 하여 다이내믹한 효과
• 각 점은 작게(w_h 기준) 그리고 시간에 따라 크기/색이 변함

📝 Rust Code

use nannou::prelude::*;

fn main() {
    nannou::app(model)
        // 초기 창 크기 (resizable = true 로 창 크기 변경 시에도 자동 반응)
        .update(update)
        .simple_window(view)
        .run();
}

struct Model {
    t: f32, // 단순 시간 누적 변수 (애니메이션 용)
}

fn model(_app: &App) -> Model {
    Model { t: 0.0 }
}

// update: 프레임마다 호출되어 시간 변수를 증가시킴
fn update(_app: &App, model: &mut Model, _update: Update) {
    // 시간 증분값: 이 값을 키우면 전체 애니메이션 속도가 빨라짐
    model.t += 0.015;
}

// view: 매 프레임마다 화면을 그림
fn view(app: &App, model: &Model, frame: Frame) {
    let draw = app.draw();

    // 배경
    draw.background().color(hsla(0.0, 0.0, 0.01, 1.0));

    // window_rect()는 현재 창의 좌표계를 리턴 (매 프레임 갱신됨)
    // - 좌표 중심은 (0,0), 좌/우/상/하 경계는 win.left(), win.right(), win.top(), win.bottom()
    let win = app.window_rect();
    // 윈도우의 짧은 쪽을 기준으로 스케일을 맞추면 화면 비율에 관계없이 보기 좋음
    let min_dim = win.w().min(win.h());

    // 레이어(링) 수: 숫자를 바꾸면 복잡도/밀도가 변함
    let layers = 30;
    for i in 0..layers {
        let fi = i as f32;
        let layer_frac = fi / (layers as f32); // 0..1 비율

        // 각 레이어의 기준 반지름: 윈도우 크기에 비례
        // 내부 레이어는 작고 바깥 레이어는 큼
        let base_r = min_dim * (0.08 + layer_frac * 0.32);

        // 회전 속도, 진동(wobble) 등 레이어마다 다르게 줌
        let rot_speed = 0.3 + layer_frac * 0.9;         // 회전 속도
        let wobble = 6.0 + layer_frac * 22.0;           // 반지름 진동 폭

        // 색상: 레이어마다 기본 hue가 다르고, 시간이 지나면서 천천히 변화
        // hue를 0..1로 만들고 사인으로 rgb를 만들어 약간 파스텔톤 느낌
        let hue = (layer_frac + model.t * 0.03).fract();
        let phase = hue * TAU;
        let r = 0.55 + 0.45 * (phase).sin();
        let g = 0.40 + 0.60 * (phase + 2.0).sin();
        let b = 0.50 + 0.50 * (phase + 4.0).sin();
        let alpha = 0.85 - layer_frac * 0.65; // 안쪽은 투명도 높고 바깥은 낮게

        // 이 레이어의 점 개수: 안쪽은 적고 바깥쪽은 많게
        let points = 18 + i * 10;

        // 레이어 회전 오프셋 (짝수/홀수 레이어 반대 방향으로 회전)
        let layer_rot = model.t * rot_speed * if i % 2 == 0 { 1.0 } else { -1.0 };

        for j in 0..points {
            let fj = j as f32;

            // 각 점의 각도: 인덱스에 따라 원주에 균등 분포시키고 레이어 회전 더함
            let angle = map_range(fj, 0.0, (points - 1) as f32, 0.0, TAU) + layer_rot;

            // 반지름 계산: 기본 반지름(base_r)에 여러 주기의 사인파를 겹쳐 세밀한 진동(노이즈 비슷한)을 만듦
            let r_noise = (model.t * (0.8 + fi * 0.6) + fj * 0.35).sin() * 0.6
                          + (model.t * (1.5 + fi * 0.4) - fj * 0.12).sin() * 0.3;
            let r_final = base_r + r_noise * wobble;

            // 극좌표 -> 직교 좌표 변환
            let x = r_final * angle.cos();
            let y = r_final * angle.sin();

            // 점 크기: 윈도우 크기에 비례(작게), 시간에 따라 약간 변동
            let base_dot = min_dim * 0.008; // 윈도우 크기에 비례한 기본 점 크기 (작게 설정)
            let dot = (base_dot * (0.6 + 0.8 * (model.t * 2.0 + fi * 0.3 + fj * 0.07).sin())).max(1.0);

            // 그리기: pt2()로 좌표를 만들고 .xy(...)를 사용
            draw.ellipse()
                .xy(pt2(x, y))
                .w_h(dot, dot)
                .rgba(r, g, b, alpha * 0.9);
        }
    }

    // 현재 그린 내용을 화면에 반영
    draw.to_frame(app, &frame).unwrap();
}