🔮 :: Globular Star Cluster

📝 Rust Code

use nannou::prelude::*;
use rand::prelude::*;
use rand_distr::{Normal, Distribution};

#[derive(Clone)]
struct Star {
    position: Vec2,
    radius: f32,
    color: Srgba,
}

struct Model {
    stars: Vec<Star>,
    rotation_speed: f32,
    trail_alpha: f32,
}

impl Model {
    fn new(app: &App) -> Self {
        app.new_window()
            .title("Globular Star Cluster (Refactored)")
            .size(1024, 1024)
            .view(Self::view)
            .build()
            .unwrap();

        const NUM_STARS: usize = 2000;
        const STD_DEV: f32 = 220.0;

        let mut rng = thread_rng();
        let normal = Normal::new(0.0, STD_DEV).unwrap();

        let stars = (0..NUM_STARS)
            .map(|_| {
                let x = normal.sample(&mut rng);
                let y = normal.sample(&mut rng);
                let pos = vec2(x, y);
                let dist_from_center = pos.length();

                let weight = (1.0 - (dist_from_center / (STD_DEV * 3.0)).min(1.0)).powf(2.0);
                let base_radius = rng.gen_range(0.3..=2.5);
                let radius = base_radius * (0.5 + 1.5 * weight);
                let base_alpha = rng.gen_range(0.5..=1.0);
                let alpha = base_alpha * (0.3 + 0.7 * weight);

                let hue_shift = rng.gen_range(-0.05..=0.05);
                let t = weight;
                let color = srgba(
                    0.9 - 0.3 * (1.0 - t) + hue_shift,
                    0.9 - 0.2 * (1.0 - t),
                    1.0 - 0.1 * t,
                    alpha,
                );

                Star {
                    position: pos,
                    radius,
                    color,
                }
            })
            .collect();

        Self {
            stars,
            rotation_speed: 0.002,
            trail_alpha: 0.1,
        }
    }

    fn update(&mut self) {
        let theta = self.rotation_speed;
        let cos_t = theta.cos();
        let sin_t = theta.sin();

        for star in &mut self.stars {
            let pos = star.position;
            star.position = vec2(
                pos.x * cos_t - pos.y * sin_t,
                pos.x * sin_t + pos.y * cos_t,
            );
        }
    }

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

        // 잔상 효과
        draw.rect()
            .wh(app.window_rect().wh())
            .color(srgba(0.0, 0.0, 0.0, model.trail_alpha));

        for star in &model.stars {
            draw.ellipse()
                .xy(star.position)
                .radius(star.radius)
                .color(star.color);

            // 글로우 효과
            draw.ellipse()
                .xy(star.position)
                .radius(star.radius * 1.3)
                .color(srgba(
                    star.color.red,
                    star.color.green,
                    star.color.blue,
                    star.color.alpha * 0.02,
                ));
        }

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

// ==========================
// nannou entry point
// ==========================
fn main() {
    nannou::app(|app| Model::new(app))
        .update(|_app, model, _update| model.update())
        .run();
}

📝 Rust Code + Comment

// Nannou의 기본 기능들을 한 번에 가져옵니다.
// (App, Frame, draw, vec2, srgba, 색상, 도형 등)
use nannou::prelude::*;

// 난수 생성을 위한 기본 기능들 (thread_rng, gen_range 등)
use rand::prelude::*;

// 확률 분포 (특히 정규 분포 = 가우시안 분포)를 사용하기 위한 크레이트
use rand_distr::{Normal, Distribution};

// 각 별(Star)의 상태를 저장하는 구조체
#[derive(Clone)]
struct Star {
    position: Vec2,  // 별의 2D 위치 (x, y 좌표)
    radius: f32,     // 별의 반지름 (크기)
    color: Srgba,    // 별의 색상 (RGBA, 알파 채널 포함)
}

// 애플리케이션 전체 상태를 관리하는 모델 구조체
struct Model {
    stars: Vec<Star>,       // 화면에 그릴 모든 별의 목록
    rotation_speed: f32,    // 전체 별 집합의 회전 속도 (라디안/프레임 단위)
    trail_alpha: f32,       // 잔상 효과를 위한 검은색 레이어의 투명도 (0.0 ~ 1.0)
}

// Model 구조체에 대한 메서드 구현
impl Model {
    // 애플리케이션 시작 시 한 번만 호출되는 초기화 함수
    fn new(app: &App) -> Self {
        // Nannou 창을 설정하고 생성합니다.
        app.new_window()
            .title("Globular Star Cluster (Refactored)") // 창 제목
            .size(1024, 1024)                            // 창 크기: 1024x1024 픽셀
            .view(Self::view)                            // 렌더링은 Self::view 메서드 사용
            .build()
            .unwrap(); // 창 생성 실패 시 panic (간단한 예제에서는 허용)

        // 상수 정의: 별의 총 개수와 정규 분포의 표준편차
        const NUM_STARS: usize = 2000;   // 별 2000개 생성
        const STD_DEV: f32 = 220.0;      // 정규 분포의 표준편차 (단위: 픽셀)

        // 현재 스레드 전용 난수 생성기 생성
        let mut rng = thread_rng();

        // 평균 0.0, 표준편차 STD_DEV인 정규 분포(가우시안 분포) 객체 생성
        // 이 분포에서 샘플링하면 중심(0,0) 근처에 밀집된 값들이 나옴
        let normal = Normal::new(0.0, STD_DEV).unwrap();

        // 별들을 정규 분포에 따라 무작위로 생성
        let stars = (0..NUM_STARS)
            .map(|_| {
                // X, Y 좌표를 독립적으로 정규 분포에서 샘플링 → 2D 가우시안 분포 효과
                let x = normal.sample(&mut rng);
                let y = normal.sample(&mut rng);
                let pos = vec2(x, y); // Vec2 타입으로 위치 생성

                // 원점(0,0)에서의 거리 계산
                let dist_from_center = pos.length();

                // 가중치(weight): 중심에서 멀어질수록 작아짐 (0~1)
                // STD_DEV * 3.0 ≈ 99.7%의 데이터가 포함되는 반경 (3σ 규칙)
                // .min(1.0)으로 1을 넘지 않도록 보장
                // .powf(2.0)로 중심 근처가 훨씬 더 강조되도록 비선형 조정
                let weight = (1.0 - (dist_from_center / (STD_DEV * 3.0)).min(1.0)).powf(2.0);

                // 기본 반지름을 0.3~2.5 사이에서 무작위 선택
                let base_radius = rng.gen_range(0.3..=2.5);
                // 가중치에 따라 반지름 조정: 중심 별일수록 더 크게
                let radius = base_radius * (0.5 + 1.5 * weight);

                // 기본 알파(투명도)를 0.5~1.0 사이에서 무작위 선택
                let base_alpha = rng.gen_range(0.5..=1.0);
                // 가중치에 따라 알파 조정: 중심 별일수록 더 불투명하게
                let alpha = base_alpha * (0.3 + 0.7 * weight);

                // 색상 조정: 중심은 흰색에 가까운 파란빛, 가장자리는 더 파란색
                // hue_shift로 약간의 색상 변동을 줘 자연스러움 추가
                let hue_shift = rng.gen_range(-0.05..=0.05);
                let t = weight; // 가독성을 위해 weight를 t로 복사
                let color = srgba(
                    0.9 - 0.3 * (1.0 - t) + hue_shift, // 빨강: 중심일수록 밝음
                    0.9 - 0.2 * (1.0 - t),             // 초록
                    1.0 - 0.1 * t,                     // 파랑: 중심일수록 약간 어두움
                    alpha,                             // 위에서 계산한 알파 값 사용
                );

                // Star 구조체 인스턴스 생성
                Star {
                    position: pos,
                    radius,
                    color,
                }
            })
            .collect(); // Iterator를 Vec<Star>로 변환

        // Model 인스턴스 반환
        Self {
            stars,
            rotation_speed: 0.002, // 매우 느린 회전 속도 (라디안/프레임)
            trail_alpha: 0.1,      // 잔상 효과의 투명도: 10% 불투명
        }
    }

    // 매 프레임마다 호출되어 별들의 위치를 업데이트 (회전 적용)
    fn update(&mut self) {
        let theta = self.rotation_speed; // 회전 각도 (매 프레임 증가량)
        let cos_t = theta.cos();         // cos(θ) — 회전 행렬 계산을 위해 미리 계산
        let sin_t = theta.sin();         // sin(θ)

        // 모든 별에 대해 2D 회전 변환 적용
        for star in &mut self.stars {
            let pos = star.position;
            // 2D 회전 공식: 
            // x' = x*cosθ - y*sinθ
            // y' = x*sinθ + y*cosθ
            star.position = vec2(
                pos.x * cos_t - pos.y * sin_t,
                pos.x * sin_t + pos.y * cos_t,
            );
        }
    }

    // 매 프레임마다 화면을 그리는 함수 (렌더링)
    fn view(app: &App, model: &Self, frame: Frame) {
        let draw = app.draw(); // 그리기 컨텍스트 가져오기

        // [잔상 효과] 이전 프레임의 내용을 완전히 지우지 않고,
        // 약간 투명한 검은색 사각형을 덮어 서서히 흐려지게 만듦
        draw.rect()
            .wh(app.window_rect().wh()) // 창 전체 크기
            .color(srgba(0.0, 0.0, 0.0, model.trail_alpha)); // 검은색 + 투명도

        // 모든 별을 순회하며 그리기
        for star in &model.stars {
            // 1. 별의 본체 그리기
            draw.ellipse()
                .xy(star.position)   // 위치
                .radius(star.radius) // 반지름
                .color(star.color);  // 색상 (알파 포함)

            // 2. 글로우(Glow) 효과: 본체보다 약간 큰 타원을 매우 투명하게 그려 빛 번짐 표현
            draw.ellipse()
                .xy(star.position)
                .radius(star.radius * 1.3) // 약 30% 더 큰 반지름
                .color(srgba(
                    star.color.red,
                    star.color.green,
                    star.color.blue,
                    star.color.alpha * 0.02, // 알파를 2%로 낮춤 → 희미한 광채
                ));
        }

        // 그린 내용을 실제 프레임 버퍼에 출력
        draw.to_frame(app, &frame).unwrap();
    }
}

// ==========================
// Nannou 애플리케이션 진입점
// ==========================
fn main() {
    // nannou::app()으로 앱 시작
    nannou::app(|app| Model::new(app)) // 초기 상태 생성
        .update(|_app, model, _update| model.update()) // 매 프레임 업데이트
        .run(); // 이벤트 루프 시작 및 실행
}

rand_distr = "0.4.3" 필요

밀도 가중치 (Distance Weighting) : 중심에서 멀어질수록 반지름과 알파값이 줄어듦
색상 변화 : 중심부는 흰색, 외곽은 푸른색/노란빛 랜덤 섞기
트레일 효과 (Motion Blur) : 매 프레임 살짝 어두운 반투명 레이어를 덧그려 부드러운 잔상 생성
부드러운 확산 효과 : 알파값을 거리 기반 곡선으로 계산 (예: alpha = exp(-r² / (2σ²)))

📌 전체 코드 개요
이 프로그램은 구상성단(Globular Star Cluster)처럼 보이는 2D 별들의 집합을 화면에 그립니다.

별들은 가우시안 분포(정규 분포)를 따라 중심에서 밀집되어 배치됩니다.
전체 별 집합이 천천히 회전하며, 잔상 효과(trail)와 글로우(glow) 효과를 통해 시각적으로 아름답게 표현됩니다.
색상과 크기는 중심에서의 거리에 따라 가중치(weight)를 적용해 자연스럽게 변화합니다.
📦 사용된 크레이트 설명
1. nannou::prelude::
Nannou 라이브러리의 핵심 기능들을 한 번에 가져옵니다.
App, Frame, draw, vec2, srgba, rect, ellipse 등 그래픽 및 앱 제어 기능 포함.
2. rand::prelude::
난수 생성을 위한 rand 크레이트의 기본 기능.
thread_rng() 등으로 스레드 로컬 난수 생성기를 사용.
3. rand_distr::{Normal, Distribution}
확률 분포를 위한 확장 크레이트.
Normal은 정규 분포(가우시안 분포)를 정의합니다.
Distribution 트레잇을 통해 .sample() 메서드로 난수를 생성할 수 있습니다.

🔍 참고: rand_distr은 rand의 확장으로, 다양한 확률 분포(정규, 감마, 베타 등)를 제공합니다.
공식 문서: https://docs.rs/rand_distr/latest/rand_distr/

1. 정규 분포(가우시안 분포)
   정의: 평균(μ)과 표준편차(σ)로 정의되는 연속 확률 분포.
   특징: 종 모양, 중심에 집중, ±1σ: 68%, ±2σ: 95%, ±3σ: 99.7%
   시각화: https://en.wikipedia.org/wiki/Normal_distribution