🔮 :: Exoplanets

SPACEBAR : 행성 회전 toggle
H : 행성의 hue 변경
R : 항성의 이름과 반지름, 행성의 궤도, 배경 별 변경
S : 스크린샷 저장

📝 Rust Code

use nannou::prelude::*;
use rand::seq::SliceRandom;
use rand::Rng;
use std::fs;

// --- Global Constants ---
const WIDTH: u32 = 540;
const HEIGHT: u32 = 960;
const ORBIT_COUNT: usize = 10; // Number of orbits
const STARFIELD_COUNT: usize = 100; // 배경 별 개수

// --- App Code ---
fn main() {
    nannou::app(model).update(update).run();
}

// App state
struct Model {
    star_position: Vec2,               // Star position
    star_radius: f32,                  // Star radius (randomized)
    orbits: Vec<(f32, f32)>,           // (orbit radius, stroke weight)
    planets: Vec<(usize, f32, f32)>,   // (orbit index, planet radius, angle in degrees)
    planet_speeds: Vec<f32>,           // 각 행성의 회전 속도
    is_rotating: bool,                 // Tracks if planets are rotating
    font: nannou::text::Font,          // 폰트
    label: String,                     // 랜덤 라벨
    planet_hue: f32,                   // 행성 색상의 hue (전체 행성 공통)
    planet_colors: Vec<(f32, f32)>,    // 각 행성의 (s, l)
    screenshot_index: usize,           // 저장되는 이미지 순번
    starfield: Vec<(Vec2, f32)>,       // (별 위치, 반지름)
}

// --- Starfield generator ---
fn generate_starfield() -> Vec<(Vec2, f32)> {
    let mut rng = rand::thread_rng();
    let mut stars = Vec::new();
    for _ in 0..STARFIELD_COUNT {
        let x = rng.gen_range(-(WIDTH as f32) / 2.0..(WIDTH as f32) / 2.0);
        let y = rng.gen_range(-(HEIGHT as f32) / 2.0..(HEIGHT as f32) / 2.0);
        let radius = rng.gen_range(0.3..1.0);
        stars.push((vec2(x, y), radius));
    }
    stars
}

// Called once to set up the model
fn model(app: &App) -> Model {
    // Create window with key press handler
    app.new_window()
        .size(WIDTH, HEIGHT)
        .view(view)
        .key_pressed(key_pressed)
        .build()
        .unwrap();

    let star_position = vec2(0.0, -480.0);

    // Random star radius
    let mut rng = rand::thread_rng();
    let star_radius: f32 = rng.gen_range(150.0..=400.0);
    println!("Star radius chosen: {}", star_radius);

    // Dynamic min orbit radius (star_radius + 50~80)
    let min_orbit_radius = star_radius + rng.gen_range(50..=80) as f32;

    // Generate random orbits
    let mut orbits = Vec::new();
    for _ in 0..ORBIT_COUNT {
        let radius = random_range(min_orbit_radius, HEIGHT as f32);
        let stroke_weight = random_range(0.3, 0.5);
        orbits.push((radius, stroke_weight));
    }
    orbits.sort_by(|a, b| a.0.partial_cmp(&b.0).unwrap());

    // Generate planets
    let mut planets = Vec::new();
    for i in 0..ORBIT_COUNT {
        let orbit_index = i;
        let planet_radius = random_range(3.0, 10.0);
        let angle_degrees = 90.0;
        planets.push((orbit_index, planet_radius, angle_degrees));
    }

    // 속도 초기화 (처음엔 0)
    let planet_speeds = vec![0.0; ORBIT_COUNT];

    // 각 행성의 (s, l) 색상 랜덤 생성 (고정)
    let mut planet_colors = Vec::new();
    for _ in 0..ORBIT_COUNT {
        let s: f32 = rng.gen_range(0.5..1.0);
        let l: f32 = rng.gen_range(0.4..0.8);
        planet_colors.push((s, l));
    }

    // --- Font & Random Label ---
    let assets = app.assets_path().expect("no assets directory found");
    let font_path = assets.join("fonts").join("font.ttf");
    let font_data = fs::read(font_path).expect("failed to read font file");
    let font = nannou::text::Font::from_bytes(font_data).expect("failed to load font");

    let names = [
        "Kepler", "Galileo", "Newton", "Herschel", "Hubble",
        "Tycho", "Halley", "Cassini", "Copernicus", "Sagan",
        "Messier", "Laplace", "Chandrasekhar", "Hawking", "Eddington",
    ];

    let name = names.choose(&mut rng).unwrap_or(&"Kepler");
    let num: u16 = rng.gen_range(100..1000);
    let label = format!("{}-{}", name, num);

    // 행성 색상 hue는 기본값 0.0
    let planet_hue = 0.0;

    // --- Starfield ---
    let starfield = generate_starfield();

    Model {
        star_position,
        star_radius,
        orbits,
        planets,
        planet_speeds,
        is_rotating: false,
        font,
        label,
        planet_hue,
        planet_colors,
        screenshot_index: 0,
        starfield,
    }
}

// Handle key press events
fn key_pressed(app: &App, model: &mut Model, key: Key) {
    match key {
        Key::Space => {
            if model.is_rotating {
                model.is_rotating = false;
            } else {
                let mut rng = rand::thread_rng();
                for speed in model.planet_speeds.iter_mut() {
                    *speed = rng.gen_range(0.1..1.0);
                }
                model.is_rotating = true;
            }
        }
        Key::S => {
            model.screenshot_index += 1;
            let filename = format!("exoplanet_{:03}.png", model.screenshot_index);
            app.main_window().capture_frame(&filename);
            println!("📸 Screenshot saved: {}", filename);
        }
        Key::H => {
            let mut rng = rand::thread_rng();
            model.planet_hue = rng.gen_range(0.0..360.0);
            println!("🎨 Hue changed to: {:.2}", model.planet_hue);
        }
        Key::R => {
            let mut rng = rand::thread_rng();

            // --- 새로운 항성 반지름 ---
            model.star_radius = rng.gen_range(150.0..=400.0);

            // --- 새로운 최소 궤도 반지름 (항성 반지름 + 50~80) ---
            let min_orbit_radius = model.star_radius + rng.gen_range(50.0..=80.0);

            // --- 궤도 새로 생성 ---
            let mut new_orbits = Vec::new();
            for _ in 0..ORBIT_COUNT {
                let radius = random_range(min_orbit_radius, HEIGHT as f32);
                let stroke_weight = random_range(0.3, 0.5);
                new_orbits.push((radius, stroke_weight));
            }
            new_orbits.sort_by(|a, b| a.0.partial_cmp(&b.0).unwrap());
            model.orbits = new_orbits;

            // --- 새로운 라벨 ---
            let names = [
                "Kepler", "Galileo", "Newton", "Herschel", "Hubble",
                "Tycho", "Halley", "Cassini", "Copernicus", "Sagan",
            ];
            let name = names.choose(&mut rng).unwrap_or(&"Kepler");
            let num: u16 = rng.gen_range(100..1000);
            model.label = format!("{}-{}", name, num);

            // --- 새로운 스타필드 ---
            model.starfield = generate_starfield();

            // --- 로그 출력 ---
            println!("✨ Star radius changed to: {:.2}", model.star_radius);
            println!("🌀 Orbits regenerated ({} total)", model.orbits.len());
            println!("🌌 Starfield regenerated ({} stars)", model.starfield.len());
            println!("🪐 Label changed to: {}", model.label);
        }
        _ => {}
    }
}

// Called every frame to update the model
fn update(_app: &App, model: &mut Model, _update: Update) {
    if model.is_rotating {
        for ((_, _, angle_degrees), speed) in model.planets.iter_mut().zip(model.planet_speeds.iter()) {
            *angle_degrees += *speed;
            if *angle_degrees >= 360.0 {
                *angle_degrees -= 360.0;
            }
        }
    }
}

// Called every frame to draw the scene
fn view(app: &App, model: &Model, frame: Frame) {
    let draw = app.draw();

    // 1. Black background
    draw.background().color(hsla(0.0, 0.0, 0.007, 1.0));

    // 2. Draw starfield
    for (pos, radius) in model.starfield.iter() {
        draw.ellipse()
            .xy(*pos)
            .radius(*radius)
            .color(hsla(0.0, 0.0, 1.0, 1.0));
    }

    // 3. Draw star
    draw.ellipse()
        .xy(model.star_position)
        .radius(model.star_radius)
        .color(hsla(200.0, 0.2, 0.8, 1.0));

    // 4. Draw orbits (gray)
    for (radius, stroke_weight) in model.orbits.iter() {
        draw.ellipse()
            .xy(model.star_position)
            .radius(*radius)
            .no_fill()
            .stroke(hsla(0.0, 0.0, 0.3, 1.0))
            .stroke_weight(*stroke_weight);
    }

    // 5. Draw planets
    for ((orbit_index, planet_radius, angle_degrees), (s, l)) in
        model.planets.iter().zip(model.planet_colors.iter())
    {
        let orbit_radius = model.orbits[*orbit_index].0;
        let angle_rad = deg_to_rad(*angle_degrees);
        let planet_pos =
            model.star_position + vec2(angle_rad.cos() * orbit_radius, angle_rad.sin() * orbit_radius);

        draw.ellipse()
            .xy(planet_pos)
            .radius(*planet_radius)
            .color(hsla(model.planet_hue, *s, *l, 1.0));
    }

    // 6. Draw random label
    draw.text(&model.label)
        .font(model.font.clone())
        .xy(vec2(0.0, -400.0))
        .font_size(24)
        .color(hsla(0.0, 0.0, 0.0, 1.0));

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

🎛️ 문법에 대한 추가 설명

for ((_, _, angle_degrees), speed) in model.planets.iter_mut().zip(model.planet_speeds.iter()) {
    *angle_degrees += *speed;
    if *angle_degrees >= 360.0 {
        *angle_degrees -= 360.0;
    }
}

행성의 궤도 인덱스와 반지름은 그대로 유지하면서, 각도와 속도만을 효율적으로 업데이트하는 우아한 방법

✅ iter_mut() 와 iter()

• iter_mut(): 컬렉션의 요소에 대한 가변 참조(&mut T) 를 제공하는 반복자. 요소 값을 수정할 수 있습니다.
• iter(): 컬렉션의 요소에 대한 불변 참조(&T) 를 제공하는 반복자. 요소 값을 읽기만 가능합니다.

✅ zip() 메서드

• 두 개의 반복자를 "짝지어" 하나의 반복자로 만듭니다.
• 예: [a, b, c].zip([1, 2, 3]) → [(a, 1), (b, 2), (c, 3)]
• 두 컬렉션의 길이가 다르면, 더 짧은 쪽에 맞춰집니다.

✅ 튜플 분해(Destructuring):

• ((_, _, angle_degrees), speed)에서:

  • 바깥 튜플: zip()이 생성한 (planet, speed) 쌍
  • 안쪽 튜플: planet은 (usize, f32, f32) 형식
  • _: 해당 위치의 값은 무시하겠다는 의미

✅ 역참조 연산자 *:

• 참조(&T 또는 &mut T)가 가리키는 실제 값을 가져옵니다.

• *angle_degrees는 &mut f32에서 실제 f32 값에 접근하여 수정할 수 있게 합니다.

✅ ⚙️🛠️📄📚🎨🖼️🧩🧠🧮🕹️🧿⏳🎛️🔮🌌🪩🗂️📝🧰🔒

아보카도
Sample
Important
Highlighting
비색
적황색
purple
hot pink
yellow
살구색
orange
green
blue