🔮 :: Sun Flares

📝 Rust Code

use nannou::prelude::*;
use nannou::noise::{NoiseFn, Perlin};
use rand::Rng;

// === 설정 상수 ===
const WIN_W: u32 = 800;
const WIN_H: u32 = 800;
const RADIUS: f32 = 200.0;

const NUM_FLARE: usize = 5000;
const CLUSTERS: usize = 12;
const TAU: f32 = std::f32::consts::TAU;
const CLUSTER_SPREAD: f32 = 0.08 * TAU;

const MIN_LEN: f32 = 30.0;
const MAX_LEN: f32 = 170.0;

const START_THICK: f32 = 0.8;
const END_THICK: f32 = 0.1;

const START_ALPHA: f32 = 0.8;
const END_ALPHA: f32 = 0.1;

const SEGMENTS: usize = 20;

// 노이즈 관련
const NOISE_SCALE: f64 = 2.0;
const NOISE_AMPLITUDE: f32 = 10.0;
const NOISE_SPEED: f64 = 0.2;

fn main() {
    nannou::app(model)
        .update(update)
        .view(view)
        .size(WIN_W, WIN_H)
        .run();
}

struct Model {
    flares: Vec<Flare>,
    perlin: Perlin,
    time: f64,
}

struct Flare {
    angle: f32,
    length: f32,
    seed: f64,
    cluster_id: usize,
}

fn model(app: &App) -> Model {
    let _window = app
        .new_window()
        .title("Clustered Curved Solar Flares (Animated)")
        .build()
        .unwrap();

    let mut rng = rand::thread_rng();
    let perlin = Perlin::new();

    let flares = generate_flares(&mut rng);

    Model {
        flares,
        perlin,
        time: 0.0,
    }
}

fn generate_flares<R: Rng>(rng: &mut R) -> Vec<Flare> {
    let mut flares = Vec::with_capacity(NUM_FLARE);
    let flares_per_cluster = NUM_FLARE / CLUSTERS;

    for c in 0..CLUSTERS {
        let cluster_angle = (c as f32) / (CLUSTERS as f32) * TAU;
        let cluster_seed = rng.gen_range(0.0..1000.0);
        
        for _ in 0..flares_per_cluster {
            let angle = cluster_angle + rng.gen_range(-CLUSTER_SPREAD..CLUSTER_SPREAD);
            let length = rng.gen_range(MIN_LEN..=MAX_LEN);
            let seed = cluster_seed + rng.gen_range(0.0..100.0);
            
            flares.push(Flare {
                angle,
                length,
                seed,
                cluster_id: c,
            });
        }
    }

    flares
}

fn update(_app: &App, model: &mut Model, update: Update) {
    model.time += update.since_last.as_secs_f64() * NOISE_SPEED;
}

fn view(app: &App, model: &Model, frame: Frame) {
    let draw = app.draw();
    draw.background().color(hsla(0.0, 0.0, 0.02, 1.0));

    let center = pt2(0.0, 0.0);
    let white = hsla(0.0, 0.0, 0.9, 1.0);

    // 중심 원 (항성)
    draw.ellipse()
        .no_fill()
        .stroke(white)
        .stroke_weight(1.0)
        .xy(center)
        .w_h(RADIUS * 2.0, RADIUS * 2.0);

    // 플레어들
    for flare in &model.flares {
        draw_flare(&draw, flare, center, &model.perlin, model.time);
    }

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

fn draw_flare(draw: &Draw, flare: &Flare, center: Point2, perlin: &Perlin, time: f64) {
    let dir = vec2(flare.angle.cos(), flare.angle.sin());
    let perp = vec2(-dir.y, dir.x);
    let base_center = center + dir * RADIUS;

    for s in 0..SEGMENTS {
        let t0 = s as f32 / SEGMENTS as f32;
        let t1 = (s + 1) as f32 / SEGMENTS as f32;

        // Perlin 기반 휘어짐 + 시간 애니메이션
        let n0 = perlin.get([t0 as f64 * NOISE_SCALE, flare.seed, time]) as f32;
        let n1 = perlin.get([t1 as f64 * NOISE_SCALE, flare.seed, time]) as f32;

        let offset0 = perp * (n0 * NOISE_AMPLITUDE);
        let offset1 = perp * (n1 * NOISE_AMPLITUDE);

        let p0 = base_center + dir * (flare.length * t0) + offset0;
        let p1 = base_center + dir * (flare.length * t1) + offset1;

        let w0 = lerp(START_THICK, END_THICK, t0);
        let w1 = lerp(START_THICK, END_THICK, t1);
        let a0 = lerp(START_ALPHA, END_ALPHA, t0);
        let a1 = lerp(START_ALPHA, END_ALPHA, t1);

        let alpha = (a0 + a1) * 0.5;
        let color = hsla(0.0, 0.0, 1.0, alpha);

        let left0 = p0 + perp * (w0 * 0.5);
        let right0 = p0 - perp * (w0 * 0.5);
        let left1 = p1 + perp * (w1 * 0.5);
        let right1 = p1 - perp * (w1 * 0.5);

        draw.tri()
            .points(left0, right0, left1)
            .color(color);
        draw.tri()
            .points(right0, right1, left1)
            .color(color);
    }
}

#[inline]
fn lerp(a: f32, b: f32, t: f32) -> f32 {
    a + (b - a) * t
}

📝 Rust Code + Comment

// Nannou의 기본 기능과 퍼린 노이즈, 랜덤 생성기 사용을 위한 모듈 임포트
use nannou::prelude::*;
use nannou::noise::{NoiseFn, Perlin}; // 퍼린 노이즈 함수
use rand::Rng; // 랜덤 숫자 생성기 트레잇

// === 설정 상수: 코드 전체에서 사용되는 고정값 정의 ===

// 창 크기 (픽셀)
const WIN_W: u32 = 800;
const WIN_H: u32 = 800;

// 중심 원(항성)의 반지름
const RADIUS: f32 = 200.0;

// 생성할 플레어(태양 플레어) 개수
const NUM_FLARE: usize = 5000;

// 플레어를 몇 개의 클러스터(무리)로 나눌지
const CLUSTERS: usize = 12;

// 원주율 × 2 (360도) — Nannou는 TAU를 기본 상수로 제공하지만 명시적 정의
const TAU: f32 = std::f32::consts::TAU;

// 각 클러스터 내에서 플레어가 퍼지는 각도 범위 (전체 원주의 8%)
const CLUSTER_SPREAD: f32 = 0.08 * TAU;

// 플레어 길이 범위 (픽셀)
const MIN_LEN: f32 = 30.0;
const MAX_LEN: f32 = 170.0;

// 플레어 두께: 시작(뿌리)과 끝(끝부분)의 선 두께
const START_THICK: f32 = 0.8; // 뿌리 부분이 두꺼움
const END_THICK: f32 = 0.1;   // 끝 부분이 얇음

// 플레어 투명도: 시작과 끝의 알파값
const START_ALPHA: f32 = 0.8; // 뿌리 부분이 선명
const END_ALPHA: f32 = 0.1;   // 끝 부분이 흐릿

// 각 플레어를 몇 개의 세그먼트(구간)로 나눌지 → 곡선 표현 정밀도
const SEGMENTS: usize = 20;

// 노이즈 애니메이션 관련 상수
const NOISE_SCALE: f64 = 2.0;       // 노이즈 입력 좌표 스케일 → 값이 클수록 더 세밀한 패턴
const NOISE_AMPLITUDE: f32 = 10.0;  // 노이즈 출력 진폭 → 플레어 휘어짐 정도
const NOISE_SPEED: f64 = 0.2;       // 시간 흐름 속도 → 애니메이션 속도 조절

// 프로그램 진입점
fn main() {
    nannou::app(model)        // 초기 상태 생성 함수
        .update(update)       // 매 프레임 상태 갱신
        .view(view)           // 렌더링 함수
        .size(WIN_W, WIN_H)   // 창 크기 설정 (앱 레벨에서 지정)
        .run();               // 실행
}

// 애플리케이션 전체 상태 구조체
struct Model {
    flares: Vec<Flare>,       // 모든 플레어 데이터
    perlin: Perlin,           // 퍼린 노이즈 생성기 인스턴스 (재사용)
    time: f64,                // 애니메이션 시간 (초 단위)
}

// 개별 플레어의 정적 속성을 저장하는 구조체
// → 애니메이션은 view에서 실시간 계산되므로, 여기선 초기 상태만 저장
struct Flare {
    angle: f32,               // 중심에서 뻗어나가는 각도 (라디안)
    length: f32,              // 플레어 총 길이
    seed: f64,                // 노이즈 패턴 고유 식별자 (같은 클러스터 내에서도 다양성 확보)
    cluster_id: usize,        // 소속 클러스터 ID (디버깅/확장용)
}

// 초기화 함수: 창 생성 및 플레어 데이터 준비
fn model(app: &App) -> Model {
    // 창 생성 및 제목 설정
    let _window = app
        .new_window()
        .title("Clustered Curved Solar Flares (Animated)")
        .build()
        .unwrap();

    // 랜덤 생성기 인스턴스 생성 (스레드 안전)
    let mut rng = rand::thread_rng();
    // 퍼린 노이즈 생성기 생성
    let perlin = Perlin::new();

    // 플레어 데이터 생성
    let flares = generate_flares(&mut rng);

    // 초기 Model 반환
    Model {
        flares,
        perlin,
        time: 0.0, // 시간 0부터 시작
    }
}

// 플레어 데이터를 클러스터 단위로 생성하는 함수
// R: Rng — 제네릭으로 랜덤 생성기 타입을 추상화 (유연성 향상)
fn generate_flares<R: Rng>(rng: &mut R) -> Vec<Flare> {
    // 메모리 사전 할당 (성능 최적화)
    let mut flares = Vec::with_capacity(NUM_FLARE);
    // 클러스터당 몇 개의 플레어를 배정할지 계산
    let flares_per_cluster = NUM_FLARE / CLUSTERS;

    // 각 클러스터 생성
    for c in 0..CLUSTERS {
        // 클러스터 중심 각도: 원을 CLUSTERS 등분
        let cluster_angle = (c as f32) / (CLUSTERS as f32) * TAU;
        // 클러스터 전체에 공유되는 랜덤 시드 (내부 다양성 확보용)
        let cluster_seed = rng.gen_range(0.0..1000.0);
        
        // 클러스터 내 플레어 생성
        for _ in 0..flares_per_cluster {
            // 중심 각도 주변에 랜덤 퍼짐
            let angle = cluster_angle + rng.gen_range(-CLUSTER_SPREAD..CLUSTER_SPREAD);
            // 길이 랜덤 설정
            let length = rng.gen_range(MIN_LEN..=MAX_LEN);
            // 고유 시드: 클러스터 시드 + 추가 랜덤 → 같은 클러스터 내에서도 다른 노이즈 패턴
            let seed = cluster_seed + rng.gen_range(0.0..100.0);
            
            // Flare 인스턴스 생성 및 추가
            flares.push(Flare {
                angle,
                length,
                seed,
                cluster_id: c,
            });
        }
    }

    flares
}

// 매 프레임 시간 업데이트 함수
fn update(_app: &App, model: &mut Model, update: Update) {
    // 경과 시간(초) × 속도 계수 → 부드러운 애니메이션 시간 흐름
    model.time += update.since_last.as_secs_f64() * NOISE_SPEED;
}

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

    // 매우 어두운 배경 (은은한 검정)
    draw.background().color(hsla(0.0, 0.0, 0.02, 1.0));

    // 화면 중앙 좌표
    let center = pt2(0.0, 0.0);
    // 흰색 (항성과 플레어 색상 기준)
    let white = hsla(0.0, 0.0, 0.9, 1.0);

    // 중심 원 (항성): 테두리만 있고 채우기 없음
    draw.ellipse()
        .no_fill()                // 내부 채우기 없음
        .stroke(white)            // 테두리 색상
        .stroke_weight(1.0)       // 테두리 두께
        .xy(center)               // 중심 위치
        .w_h(RADIUS * 2.0, RADIUS * 2.0); // 지름 = 반지름 × 2

    // 모든 플레어 그리기
    for flare in &model.flares {
        draw_flare(&draw, flare, center, &model.perlin, model.time);
    }

    // 프레임에 그리기 명령 적용
    draw.to_frame(app, &frame).unwrap();
}

// 개별 플레어를 곡선 형태로 그리는 함수
// - draw: 그리기 명령 객체 (불변 참조)
// - flare: 그릴 플레어 데이터
// - center: 항성 중심 좌표
// - perlin: 노이즈 생성기 (불변 참조)
// - time: 현재 애니메이션 시간
fn draw_flare(draw: &Draw, flare: &Flare, center: Point2, perlin: &Perlin, time: f64) {
    // 플레어 방향 단위 벡터 (각도 → 벡터 변환)
    let dir = vec2(flare.angle.cos(), flare.angle.sin());
    // 방향에 수직인 벡터 (두께 계산용)
    let perp = vec2(-dir.y, dir.x);
    // 플레어 시작점: 항성 표면 (반지름만큼 떨어진 지점)
    let base_center = center + dir * RADIUS;

    // 플레어를 SEGMENTS 개의 구간으로 나누어 곡선 표현
    for s in 0..SEGMENTS {
        // 현재 구간의 시작(t0)과 끝(t1) 비율 (0.0 ~ 1.0)
        let t0 = s as f32 / SEGMENTS as f32;
        let t1 = (s + 1) as f32 / SEGMENTS as f32;

        // 퍼린 노이즈 기반 휘어짐 계산:
        // - x: 구간 위치 (t0, t1) × 스케일
        // - y: 플레어 고유 시드 → 고유 패턴 보장
        // - z: 시간 → 애니메이션
        let n0 = perlin.get([t0 as f64 * NOISE_SCALE, flare.seed, time]) as f32;
        let n1 = perlin.get([t1 as f64 * NOISE_SCALE, flare.seed, time]) as f32;

        // 수직 방향으로 휘어짐 오프셋 계산
        let offset0 = perp * (n0 * NOISE_AMPLITUDE);
        let offset1 = perp * (n1 * NOISE_AMPLITUDE);

        // 실제 3D 곡선 상의 점 계산:
        // - 기본 직선 위치 + 노이즈 오프셋
        let p0 = base_center + dir * (flare.length * t0) + offset0;
        let p1 = base_center + dir * (flare.length * t1) + offset1;

        // 두께와 투명도를 선형 보간(lerp)으로 부드럽게 변화
        let w0 = lerp(START_THICK, END_THICK, t0);
        let w1 = lerp(START_THICK, END_THICK, t1);
        let a0 = lerp(START_ALPHA, END_ALPHA, t0);
        let a1 = lerp(START_ALPHA, END_ALPHA, t1);

        // 평균 알파값으로 색상 결정 (간단한 근사)
        let alpha = (a0 + a1) * 0.5;
        let color = hsla(0.0, 0.0, 1.0, alpha); // 흰색, 알파만 변화

        // 사다리꼴을 두 개의 삼각형으로 분할하여 그리기:
        // - 왼쪽/오른쪽 경계점 계산 (두께 기반)
        let left0 = p0 + perp * (w0 * 0.5);
        let right0 = p0 - perp * (w0 * 0.5);
        let left1 = p1 + perp * (w1 * 0.5);
        let right1 = p1 - perp * (w1 * 0.5);

        // 첫 번째 삼각형 (왼쪽 반)
        draw.tri()
            .points(left0, right0, left1)
            .color(color);
        // 두 번째 삼각형 (오른쪽 반)
        draw.tri()
            .points(right0, right1, left1)
            .color(color);
    }
}

// 선형 보간(Linear Interpolation) 함수
// - a: 시작값
// - b: 끝값
// - t: 보간 비율 (0.0=시작, 1.0=끝)
// 예: lerp(10.0, 20.0, 0.5) → 15.0
#[inline]
fn lerp(a: f32, b: f32, t: f32) -> f32 {
    a + (b - a) * t
}

🔍 #[inline] 어트리뷰트

• 컴파일러에게 "이 함수를 인라인 확장하라"고 힌트를 주는 어트리뷰트(attribute).
• 동작:
  • 일반 함수 호출 시: 스택에 인자 저장 → 함수로 점프 → 반환 → 스택 복원 (오버헤드 있음)
  • #[inline] 함수: 컴파일 시 함수 코드를 호출 위치에 직접 삽입 → 함수 호출 오버헤드 제거
• 사용 이유:
  • 매우 짧고 자주 호출되는 함수(예: lerp, min, max)에 적합
  • 성능 최적화 목적 (특히 루프 내에서 수천/수만 번 호출될 경우)
• 주의:
  • 컴파일러는 이 힌트를 무시할 수 있음 (함수가 너무 크면 인라인하지 않음)
  • #[inline(always)]은 강제 인라인 (위험할 수 있음)
• 이 코드에서의 역할:
  • lerp는 플레어 하나당 4번, 전체 5000개 플레어 × 20 세그먼트 = 40만 번 이상 호출
  • 인라인으로 오버헤드 제거 → 렌더링 성능 향상

💡 Rust 표준 라이브러리의 많은 수학 함수(f32::min, clamp 등)도 #[inline]으로 정의되어 있습니다.