🔮 :: Fireworks Generator

📝 Rust Code

use nannou::prelude::*;

// 앱의 상태를 관리하는 Model 구조체
#[derive(Debug)]
struct Model {
    // 윈도우 ID
    window: WindowId,

    // 시간 관련
    time: f32,
    frame_count: u64,

    // 마우스 상태
    mouse_pos: Point2,
    mouse_pressed: bool,

    // 키보드 상태
    keys_pressed: std::collections::HashSet<Key>,

    // 앱 상태
    is_paused: bool,
    background_color: Rgb<u8>,

    // 사용자 정의 데이터
    particles: Vec<Particle>,
}

// 예시용 파티클 구조체
#[derive(Debug, Clone)]
struct Particle {
    position: Point2,
    velocity: Vec2,
    color: Rgb<u8>,
    size: f32,
    life: f32,
}

impl Particle {
    fn new(pos: Point2) -> Self {
        Self {
            position: pos,
            velocity: vec2(random_range(-2.0, 2.0), random_range(-2.0, 2.0)),
            color: rgb(
                random_range(0, 255),
                random_range(0, 255),
                random_range(0, 255),
            ),
            size: random_range(2.0, 8.0),
            life: 1.5, // 생존 주기 증가
        }
    }

    fn update(&mut self) {
        self.position += self.velocity;
        self.life -= 0.005; // 감소 속도 절반으로 줄임
        self.velocity *= 0.99; // 마찰력
    }

    fn is_alive(&self) -> bool {
        self.life > 0.0
    }
}

fn main() {
    nannou::app(model).update(update).event(event).run();
}

// 모델 초기화 함수
fn model(app: &App) -> Model {
    // 윈도우 생성 및 설정
    let window_id = app
        .new_window()
        .title("Fireworks Generator")
        .size(800, 800)
        .view(view)
        .build()
        .unwrap();

    Model {
        window: window_id,
        time: 0.0,
        frame_count: 0,
        mouse_pos: pt2(0.0, 0.0),
        mouse_pressed: false,
        keys_pressed: std::collections::HashSet::new(),
        is_paused: false,
        background_color: rgb(20, 20, 30),
        particles: Vec::new(),
    }
}

// 업데이트 함수 - 매 프레임마다 호출
fn update(app: &App, model: &mut Model, _update: Update) {
    if model.is_paused {
        return;
    }

    // 시간 업데이트
    model.time = app.time;
    model.frame_count += 1;

    // 마우스 위치 업데이트
    model.mouse_pos = app.mouse.position();

    // 파티클 업데이트
    for particle in &mut model.particles {
        particle.update();
    }

    // 죽은 파티클 제거
    model.particles.retain(|p| p.is_alive());

    // 마우스를 누르고 있으면 파티클 생성 (더 많이)
    if model.mouse_pressed && model.frame_count % 2 == 0 {
        model.particles.push(Particle::new(model.mouse_pos));
    }

    // 파티클 수 제한 증가
    if model.particles.len() > 500 {
        model.particles.drain(0..100);
    }
}

// 이벤트 처리 함수
fn event(app: &App, model: &mut Model, event: Event) {
    match event {
        Event::WindowEvent {
            simple: Some(event),
            ..
        } => {
            match event {
                // 키보드 이벤트
                KeyPressed(key) => {
                    model.keys_pressed.insert(key);
                    handle_key_pressed(app, model, key);
                }
                KeyReleased(key) => {
                    model.keys_pressed.remove(&key);
                }

                // 마우스 이벤트
                MousePressed(_button) => {
                    model.mouse_pressed = true;
                }
                MouseReleased(_button) => {
                    model.mouse_pressed = false;
                }
                MouseMoved(_pos) => {
                    // 마우스 위치는 update에서 처리
                }

                // 윈도우 리사이즈
                Resized(_size) => {
                    // 필요시 리사이즈 로직 추가
                }

                _ => {}
            }
        }
        _ => {}
    }
}

// 키보드 입력 처리
fn handle_key_pressed(app: &App, model: &mut Model, key: Key) {
    match key {
        Key::Space => {
            model.is_paused = !model.is_paused;
        }
        Key::C => {
            model.particles.clear();
        }
        Key::R => {
            // Random background color
            model.background_color = rgb(
                random_range(0, 255),
                random_range(0, 255),
                random_range(0, 255),
            );
        }
        Key::S => {
            // Save screenshot
            let file_path = app
                .project_path()
                .expect("Cannot find project path")
                .join("screenshots")
                .join(format!("screenshot_{}.png", model.frame_count));

            if let Some(parent) = file_path.parent() {
                std::fs::create_dir_all(parent).ok();
            }

            app.window(model.window)
                .expect("Cannot find window")
                .capture_frame(file_path);
        }
        Key::Escape => {
            app.quit();
        }
        _ => {}
    }
}

// 렌더링 함수
fn view(app: &App, model: &Model, frame: Frame) {
    let draw = app.draw();

    // 배경 그리기
    draw.background().color(model.background_color);

    // 파티클 그리기
    for particle in &model.particles {
        let alpha = particle.life;
        let color = rgba(
            particle.color.red as f32 / 255.0,
            particle.color.green as f32 / 255.0,
            particle.color.blue as f32 / 255.0,
            alpha,
        );

        draw.ellipse()
            .xy(particle.position)
            .radius(particle.size)
            .color(color);
    }

    // Debug info (top-left) - positioned within screen bounds
    let win = app.window_rect();

    // Background for debug text
    draw.rect()
        .xy(pt2(win.left() + 100.0, win.top() - 60.0))
        .w_h(180.0, 90.0)
        .color(rgba(0.0, 0.0, 0.0, 0.7));

    draw.text(&format!("Frame: {}", model.frame_count))
        .xy(pt2(win.left() + 20.0, win.top() - 30.0))
        .font_size(16)
        .color(WHITE);

    draw.text(&format!("Particles: {}", model.particles.len()))
        .xy(pt2(win.left() + 20.0, win.top() - 50.0))
        .font_size(16)
        .color(WHITE);

    draw.text(&format!("Time: {:.2}s", model.time))
        .xy(pt2(win.left() + 20.0, win.top() - 70.0))
        .font_size(16)
        .color(WHITE);

    if model.is_paused {
        draw.text("PAUSED")
            .xy(pt2(0.0, 0.0))
            .font_size(48)
            .color(RED);
    }

    // Control guide (bottom-right) - positioned within screen bounds
    let guide_text = [
        "SPACE: Play/Pause",
        "C: Clear particles",
        "R: Random background",
        "S: Save screenshot",
        "Mouse: Create particles",
        "ESC: Exit",
    ];

    // Background for guide text
    draw.rect()
        .xy(pt2(win.right() - 120.0, win.bottom() + 70.0))
        .w_h(220.0, 130.0)
        .color(rgba(0.0, 0.0, 0.0, 0.7));

    for (i, text) in guide_text.iter().enumerate() {
        draw.text(text)
            .xy(pt2(
                win.right() - 220.0,
                win.bottom() + 20.0 + (i as f32 * 20.0),
            ))
            .font_size(14)
            .color(WHITE);
    }

    // 화면에 그리기
    draw.to_frame(app, &frame).unwrap();
}