🔮 :: Radial Dreams

📝 Rust Code

use nannou::prelude::*;
use std::path::Path;

struct Circle {
    radius: f32,        // 중심으로부터의 거리
    angle: f32,         // 현재 각도
    size: f32,          // 원의 크기
    hue: f32,           // 색상
    speed_factor: f32,  // 속도 계수
}

impl Circle {
    fn new(radius: f32, initial_angle: f32, hue: f32) -> Self {
        // 중심에 가까울수록 빠른 속도, 외곽에 갈수록 느린 속도
        let speed_factor = (300.0 - radius) / 300.0;
        let size = map_range(radius, 0.0, 300.0, 15.0, 3.0); // 중심은 크게, 외곽은 작게
        
        Circle {
            radius,
            angle: initial_angle,
            size,
            hue,
            speed_factor,
        }
    }
    
    fn update(&mut self, base_speed: f32) {
        // 속도 계수를 적용한 회전
        self.angle += base_speed * self.speed_factor;
    }
    
    fn position(&self) -> Vec2 {
        vec2(
            self.radius * self.angle.cos(),
            self.radius * self.angle.sin(),
        )
    }
}

struct Model {
    circles: Vec<Circle>,
    counter: u32,
    base_rotation_speed: f32,
    trail_alpha: f32, // 궤적의 투명도
}

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

fn model(app: &App) -> Model {
    app.new_window().size(800, 800).view(view).build().unwrap();
    
    let mut circles = Vec::new();
    
    // 100개의 원을 다양한 반지름과 각도로 생성
    for i in 0..100 {
        let radius = random_range(20.0, 300.0);
        let initial_angle = random_range(0.0, TAU); // TAU = 2π
        let hue = random_range(0.0, 1.0);
        
        circles.push(Circle::new(radius, initial_angle, hue));
    }
    
    Model {
        circles,
        counter: 1,
        base_rotation_speed: 0.015,
        trail_alpha: 0.05, // 낮은 값으로 긴 궤적 효과
    }
}

fn update(_app: &App, model: &mut Model, _update: Update) {
    // 모든 원들의 위치 업데이트
    for circle in &mut model.circles {
        circle.update(model.base_rotation_speed);
    }
}

fn event(app: &App, model: &mut Model, event: Event) {
    if let Event::WindowEvent { simple: Some(WindowEvent::KeyPressed(key)), .. } = event {
        match key {
            Key::P => {
                save_frame(app, model, "png");
            }
            Key::J => {
                save_frame(app, model, "jpg");
            }
            Key::C => {
                // 원들을 다시 초기화 (새로운 패턴)
                reset_circles(model);
            }
            Key::Plus | Key::Equals => {
                // 속도 증가
                model.base_rotation_speed += 0.005;
                println!("속도 증가: {:.3}", model.base_rotation_speed);
            }
            Key::Minus => {
                // 속도 감소
                model.base_rotation_speed = (model.base_rotation_speed - 0.005).max(0.001);
                println!("속도 감소: {:.3}", model.base_rotation_speed);
            }
            Key::T => {
                // 궤적 길이 조절
                model.trail_alpha = if model.trail_alpha < 0.1 { 0.3 } else { 0.05 };
                println!("궤적 투명도: {:.2}", model.trail_alpha);
            }
            _ => {}
        }
    }
}

fn reset_circles(model: &mut Model) {
    model.circles.clear();
    
    for _ in 0..100 {
        let radius = random_range(20.0, 300.0);
        let initial_angle = random_range(0.0, TAU);
        let hue = random_range(0.0, 1.0);
        
        model.circles.push(Circle::new(radius, initial_angle, hue));
    }
    
    println!("새로운 패턴 생성됨");
}

fn save_frame(app: &App, model: &mut Model, format: &str) {
    let filename = format!("output_{}.{}", model.counter, format);
    let path = Path::new(&filename);
    let window = app.main_window();
    window.capture_frame(path);
    
    println!("프레임 저장: {}", filename);
    model.counter += 1;
}

fn view(app: &App, model: &Model, frame: Frame) {
    let draw = app.draw();
    
    // 궤적 효과를 위한 반투명 배경
    draw.rect()
        .w_h(800.0, 800.0)
        .color(srgba(0.0, 0.0, 0.0, model.trail_alpha));
    
    // 모든 원들 그리기
    for circle in &model.circles {
        let pos = circle.position();
        
        // HSL 색상으로 다채로운 효과
        let saturation = map_range(circle.radius, 20.0, 300.0, 1.0, 0.6);
        let lightness = map_range(circle.speed_factor, 0.0, 1.0, 0.3, 0.8);
        
        draw.ellipse()
            .xy(pos)
            .radius(circle.size)
            .color(hsl(circle.hue, saturation, lightness))
            .stroke_weight(0.5)
            .stroke_color(hsla(circle.hue, saturation, lightness + 0.2, 0.8));
    }
    
    // 중심점 표시 (선택적)
    draw.ellipse()
        .xy(vec2(0.0, 0.0))
        .radius(2.0)
        .color(WHITE);
    
    // Title and UI info display
    draw.text("Radial Dreams")
        .xy(vec2(0.0, 350.0))
        .font_size(24)
        .color(hsla(0.15, 0.8, 0.9, 0.8))
        .center_justify();
    
    let info_text = format!(
        "Speed: {:.3} | Trail: {:.2}\nP: Save PNG, J: Save JPG, C: New Pattern\n+/-: Speed Control, T: Trail Toggle", 
        model.base_rotation_speed, 
        model.trail_alpha
    );
    
    draw.text(&info_text)
        .xy(vec2(-380.0, 320.0))
        .font_size(12)
        .color(WHITE)
        .left_justify();
    
    draw.to_frame(app, &frame).unwrap();
}