🔮 :: Spinning Spiral Pulse

📝 Rust Code

use nannou::prelude::*;
use nannou::noise::*; // 펄린 노이즈를 사용하기 위해 추가

struct Model {
    angle: f32,
    spiral_params: SpiralParams,
    noise: Perlin, // 펄린 노이즈 생성기 추가
    noise_seed: u32, // 노이즈 시드 (시간에 따라 변화시킬 것)
}

struct SpiralParams {
    turns: f32,
    points_count: usize,
    spacing: f32,
    max_radius: f32,
    noise_strength: f32, // 노이즈 강도 매개변수 추가
    noise_scale: f32, // 노이즈 스케일 매개변수 추가
}

impl Default for SpiralParams {
    fn default() -> Self {
        Self {
            turns: 22.0,
            points_count: 3000,
            spacing: 3.0,
            max_radius: 500.0,
            noise_strength: 15.0, // 노이즈에 의한 반지름 변화 최대 강도
            noise_scale: 0.02, // 노이즈의 공간적 스케일 (값이 작을수록 더 세밀한 변화)
        }
    }
}

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

fn model(app: &App) -> Model {
    let _window = app
        .new_window()
        .title("흔들리는 나선")
        .size(800, 800)
        .view(view)
        .build()
        .unwrap();

    Model {
        angle: 0.0,
        spiral_params: SpiralParams::default(),
        noise: Perlin::new(), // 펄린 노이즈 생성기 초기화
        noise_seed: 0, // 초기 노이즈 시드
    }
}

fn update(_app: &App, model: &mut Model, _update: Update) {
    model.angle -= 0.01;
    model.noise_seed += 1; // 시간에 따라 노이즈 시드 증가 (애니메이션 효과)
}

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

    // 배경
    draw.background().color(BLACK);

    // 회전을 적용한 새로운 Draw 인스턴스 생성
    let draw = draw.rotate(model.angle);

    // 나선 그리기
    let params = &model.spiral_params;
    let max_t = params.turns * TAU;

    for i in 0..params.points_count - 1 {
        let t1 = ((i as f32) / ((params.points_count - 1) as f32)) * max_t;
        let t2 = (((i + 1) as f32) / ((params.points_count - 1) as f32)) * max_t;

        // 기본 반지름 계산
        let base_r1 = params.spacing * t1;
        let base_r2 = params.spacing * t2;

        if base_r1 > params.max_radius {
            break;
        }

        // 펄린 노이즈를 적용한 반지름 계산
        // 노이즈 입력: 각도(t)와 시간(noise_seed)을 함께 사용
        let noise_val1 = model.noise.get([
            (t1 as f64) * (params.noise_scale as f64),
            (model.noise_seed as f64) * 0.01, // 시간에 따른 변화
        ]) as f32;

        let noise_val2 = model.noise.get([
            (t2 as f64) * (params.noise_scale as f64),
            (model.noise_seed as f64) * 0.01, // 시간에 따른 변화
        ]) as f32;

        // 노이즈 강도 적용 (-1.0 ~ 1.0 범위의 노이즈를 원하는 강도로 스케일링)
        let r1 = base_r1 + noise_val1 * params.noise_strength;
        let r2 = base_r2 + noise_val2 * params.noise_strength;

        // 극좌표계에서 데카르트 좌표계로 변환
        let p1 = pt2(r1 * t1.cos(), r1 * t1.sin());
        let p2 = pt2(r2 * t2.cos(), r2 * t2.sin());

        let progress = (i as f32) / ((params.points_count - 1) as f32);
        let alpha = map_range(progress, 0.0, 1.0, 0.1, 0.9);

        let hue = map_range(progress, 0.0, 1.0, 0.8, 0.5);
        let saturation = map_range(progress, 0.0, 1.0, 0.3, 0.8);
        let lightness = map_range(progress, 0.0, 1.0, 0.3, 0.7);

        let weight = map_range(progress, 0.0, 1.0, 0.3, 2.5);

        draw.line().start(p1).end(p2).weight(weight).color(hsla(hue, saturation, lightness, alpha));
    }

    // 중심점
    draw.ellipse().radius(3.0).color(hsla(0.6, 0.8, 0.9, 0.8));

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