🔮 :: Shrinking Iris

📝 Rust Code

use nannou::prelude::*;

const NUM_PARTICLES: usize = 8_000;
const MIN_DIST: f32 = 300.0;
const MAX_DIST: f32 = 600.0;
const PARTICLE_RADIUS: f32 = 1.0;
const OBSTACLE_RADIUS: f32 = 100.0;
const FORCE_MAG: f32 = 0.08;
const FRICTION: f32 = 0.99;
const ELASTICITY: f32 = 2.5;
const ENERGY_LOSS: f32 = 0.9;
const MAX_COLLISION: u32 = 15;
const STOP_VEL: f32 = 0.1;
const WINDOW_SIZE: f32 = 800.0;

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

struct Particle {
    position: Vec2,
    velocity: Vec2,
    collision_count: u32,
    is_stopped: bool,
}

struct Model {
    particles: Vec<Particle>,
}

fn model(app: &App) -> Model {
    app.new_window()
        .size(WINDOW_SIZE as u32, WINDOW_SIZE as u32)
        .view(view)
        .build()
        .unwrap();

    let mut particles = Vec::with_capacity(NUM_PARTICLES);
    for _ in 0..NUM_PARTICLES {
        let angle = random_range(0.0, TAU);
        let dist = random_range(MIN_DIST, MAX_DIST);
        let position = vec2(angle.cos(), angle.sin()) * dist;
        particles.push(Particle {
            position,
            velocity: Vec2::ZERO,
            collision_count: 0,
            is_stopped: false,
        });
    }
    Model { particles }
}

fn update(_app: &App, model: &mut Model, _update: Update) {
    let obstacle_pos = vec2(0.0, 0.0);

    for p in model.particles.iter_mut() {
        if p.is_stopped {
            continue;
        }
        let dir = (obstacle_pos - p.position).normalize_or_zero();
        p.velocity += dir * FORCE_MAG;
        p.velocity *= FRICTION;
        p.position += p.velocity;

        // 충돌 처리 함수 분리하면 더 깔끔
        handle_collision(p, obstacle_pos);
    }
}

fn handle_collision(p: &mut Particle, obstacle_pos: Vec2) {
    let to_particle = p.position - obstacle_pos;
    let dist = to_particle.length();
    let min_dist = OBSTACLE_RADIUS + PARTICLE_RADIUS;

    if dist < min_dist {
        p.collision_count += 1;
        let normal = to_particle.normalize_or_zero();
        p.position = obstacle_pos + normal * min_dist;
        let v_dot_n = p.velocity.dot(normal);
        p.velocity -= ELASTICITY * v_dot_n * normal;
        p.velocity *= ENERGY_LOSS;
        if p.collision_count >= MAX_COLLISION || p.velocity.length() < STOP_VEL {
            p.is_stopped = true;
            p.velocity = Vec2::ZERO;
        }
    }
}

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

    let frame_no = frame.nth();
    if frame_no == 0 {
        draw.background().color(hsla(0.0, 0.0, 0.0, 1.0));
    } else {
        draw.rect()
        .w_h(WINDOW_SIZE, WINDOW_SIZE)
        .color(hsla(0.0, 0.0, 0.0, 0.1));
    }    

    draw.ellipse()
        .xy(pt2(0.0, 0.0))
        .radius(OBSTACLE_RADIUS)
        .color(hsla(0.0, 0.0, 0.0, 0.1));

    for p in &model.particles {
        draw.ellipse()
            .xy(p.position)
            .radius(PARTICLE_RADIUS)
            .color(rgba(0.9, 0.9, 0.9, 0.5));
    }

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

📝 Rust Code + Comment

// =============================================================================
// 0. 전역 상수 정의 (Global Simulation Parameters)
// =============================================================================
// 입자 시스템의 동작을 제어하는 조정 가능한 파라미터들.
// 이 값을 수정하면 시뮬레이션의 속도, 밀도, 충돌 반응 등을 쉽게 실험할 수 있음.

/// 총 입자 수: 많을수록 시각적으로 풍부하지만 성능 부하 증가
const NUM_PARTICLES: usize = 8_000;

/// 입자 초기 배치 최소 거리 (중심점 기준, 픽셀 단위)
/// 너무 가까우면 시작 시 과도한 충돌 발생
const MIN_DIST: f32 = 300.0;

/// 입자 초기 배치 최대 거리 (중심점 기준, 픽셀 단위)
const MAX_DIST: f32 = 600.0;

/// 개별 입자의 시각적 반지름 (렌더링 크기, 픽셀 단위)
const PARTICLE_RADIUS: f32 = 1.0;

/// 중앙 장애물(원)의 반지름 (픽셀 단위)
const OBSTACLE_RADIUS: f32 = 100.0;

/// 중앙 장애물이 입자에 가하는 인력의 세기
/// 값이 클수록 입자가 더 빠르게 중심으로 끌림
const FORCE_MAG: f32 = 0.08;

/// 감속 마찰 계수 (0.0 ~ 1.0)
/// 1.0 = 마찰 없음, 0.9 = 매 프레임 10% 감속
const FRICTION: f32 = 0.99;

/// 충돌 탄성 계수 (반발 강도)
/// 1.0 = 완전 탄성 충돌, >1.0 = 에너지 증폭 (과도한 튕김), <1.0 = 흡수
const ELASTICITY: f32 = 2.5;

/// 충돌 후 에너지 손실 비율 (0.0 ~ 1.0)
/// 1.0 = 에너지 보존, 0.9 = 10% 에너지 손실
const ENERGY_LOSS: f32 = 0.9;

/// 입자가 멈추기 전까지 허용되는 최대 충돌 횟수
/// 이 횟수를 초과하면 입자는 정지됨 (성능/시각적 안정화)
const MAX_COLLISION: u32 = 15;

/// 입자가 "정지했다"고 간주되는 속도 임계값 (픽셀/프레임)
/// 이보다 느리면 움직임이 눈에 띄지 않으므로 정지 처리
const STOP_VEL: f32 = 0.1;

/// 윈도우 크기 (너비 = 높이 = 정사각형)
const WINDOW_SIZE: f32 = 800.0;

// =============================================================================
// 1. 메인 함수 (Application Entry Point)
// =============================================================================
// nannou 애플리케이션 시작점.
// `model`, `update`, `view` 콜백을 등록하고 실행.

use nannou::prelude::*;

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

// =============================================================================
// 2. 입자 구조체 정의 (Particle State)
// =============================================================================
// 각 입자의 물리 상태를 저장하는 데이터 구조.

struct Particle {
    /// 현재 위치 (윈도우 중심이 (0,0)인 월드 좌표계)
    position: Vec2,

    /// 현재 속도 (프레임당 이동 벡터)
    velocity: Vec2,

    /// 중앙 장애물과의 충돌 횟수
    /// 일정 횟수 이상 충돌 시 입자를 정지시켜 성능/시각적 안정화
    collision_count: u32,

    /// 입자가 더 이상 움직이지 않는지 여부
    /// true이면 업데이트 및 렌더링 최적화 가능
    is_stopped: bool,
}

// =============================================================================
// 3. 모델 정의 (Simulation State)
// =============================================================================
// 전체 시뮬레이션의 상태를 관리하는 구조체.
// 모든 입자와 장애물 정보를 포함.

struct Model {
    /// 모든 입자 인스턴스를 저장하는 벡터
    particles: Vec<Particle>,
}

// =============================================================================
// 4. 모델 초기화 함수 (Setup Simulation)
// =============================================================================
// 애플리케이션 시작 시 한 번만 호출됨.
// 윈도우 생성, 입자 초기 배치 등을 수행.

fn model(app: &App) -> Model {
    // 윈도우 생성: 크기 설정 및 뷰 콜백 등록
    app.new_window()
        .size(WINDOW_SIZE as u32, WINDOW_SIZE as u32)
        .view(view)
        .build()
        .unwrap();

    // 입자 벡터 사전 할당 (성능 최적화)
    let mut particles = Vec::with_capacity(NUM_PARTICLES);

    // 각 입자를 원형으로 무작위 배치
    for _ in 0..NUM_PARTICLES {
        // 0 ~ 2π 사이의 무작위 각도 (TAU = 2π)
        let angle = random_range(0.0, TAU);
        // MIN_DIST ~ MAX_DIST 사이의 무작위 거리
        let dist = random_range(MIN_DIST, MAX_DIST);
        // 극좌표 → 직교좌표 변환: (r*cosθ, r*sinθ)
        let position = vec2(angle.cos(), angle.sin()) * dist;

        // 초기 속도는 0, 충돌 횟수 0, 정지 상태 아님
        particles.push(Particle {
            position,
            velocity: Vec2::ZERO,
            collision_count: 0,
            is_stopped: false,
        });
    }

    Model { particles }
}

// =============================================================================
// 5. 업데이트 함수 (Per-Frame Physics Simulation)
// =============================================================================
// 매 프레임마다 입자의 물리 시뮬레이션을 수행.
// 인력 적용 → 속도/위치 업데이트 → 충돌 처리 순서로 진행.

fn update(_app: &App, model: &mut Model, _update: Update) {
    // 중앙 장애물의 위치 (윈도우 중심)
    let obstacle_pos = vec2(0.0, 0.0);

    // 모든 입자에 대해 물리 업데이트 수행
    for p in model.particles.iter_mut() {
        // 이미 정지된 입자는 건너뜀 (성능 최적화)
        if p.is_stopped {
            continue;
        }

        // 1. 중앙 장애물 방향으로 인력(force) 적용
        //    (장애물 - 입자 위치) = 입자를 장애물 쪽으로 끌어당기는 방향 벡터
        let dir = (obstacle_pos - p.position).normalize_or_zero();
        p.velocity += dir * FORCE_MAG;

        // 2. 마찰(friction) 적용: 속도를 약간 감소시켜 자연스러운 감속 구현
        p.velocity *= FRICTION;

        // 3. 위치 업데이트: 현재 속도만큼 이동
        p.position += p.velocity;

        // 4. 충돌 처리: 장애물과의 충돌 여부 확인 및 반응
        handle_collision(p, obstacle_pos);
    }
}

// =============================================================================
// 6. 충돌 처리 함수 (Collision Response Logic)
// =============================================================================
// 입자가 중앙 장애물(원)과 충돌했는지 검사하고,
// 충돌 시 위치 보정, 속도 반사, 에너지 손실, 정지 조건 등을 처리.

fn handle_collision(p: &mut Particle, obstacle_pos: Vec2) {
    // 입자 중심에서 장애물 중심까지의 벡터
    let to_particle = p.position - obstacle_pos;
    // 두 중심 사이의 거리
    let dist = to_particle.length();
    // 충돌 판단 기준 거리 = 장애물 반지름 + 입자 반지름
    let min_dist = OBSTACLE_RADIUS + PARTICLE_RADIUS;

    // 충돌 발생 조건: 실제 거리 < 최소 허용 거리
    if dist < min_dist {
        // 충돌 횟수 증가
        p.collision_count += 1;

        // 법선 벡터: 장애물 중심에서 입자 방향으로 향함 (충돌 면의 수직 방향)
        let normal = to_particle.normalize_or_zero();

        // 위치 보정: 입자를 장애물 표면에 딱 맞도록 이동 (침투 방지)
        p.position = obstacle_pos + normal * min_dist;

        // 속도 벡터를 법선 방향으로 투영 → 충돌 방향 성분만 추출
        let v_dot_n = p.velocity.dot(normal);

        // 탄성 반사: 
        //   v' = v - (1 + elasticity) * (v·n) * n
        // 여기서는 (1 + elasticity) 대신 `ELASTICITY`를 직접 사용
        // ELASTICITY > 1.0이면 반사 시 속도 증폭 (과도한 튕김 효과)
        p.velocity -= ELASTICITY * v_dot_n * normal;

        // 에너지 손실 적용: 충돌 후 속도 감소
        p.velocity *= ENERGY_LOSS;

        // 정지 조건 체크:
        //   - 최대 충돌 횟수 도달 OR
        //   - 속도가 매우 느려져 눈에 띄지 않음
        if p.collision_count >= MAX_COLLISION || p.velocity.length() < STOP_VEL {
            p.is_stopped = true;
            p.velocity = Vec2::ZERO; // 완전 정지
        }
    }
}

// =============================================================================
// 7. 뷰 함수 (Rendering)
// =============================================================================
// 매 프레임 화면에 시뮬레이션 결과를 렌더링.
// 배경 페이드 효과, 장애물, 입자 등을 그림.

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

    // 프레임 번호 가져오기 (첫 프레임 여부 확인용)
    let frame_no = frame.nth();

    if frame_no == 0 {
        // 첫 프레임: 완전 검은 배경으로 초기화
        draw.background().color(hsla(0.0, 0.0, 0.0, 1.0));
    } else {
        // 이후 프레임: 약간 투명한 검은 사각형을 전체 화면에 덮어
        // 이전 프레임의 흔적을 서서히 흐리게 만듦 (trail 효과)
        draw.rect()
            .w_h(WINDOW_SIZE, WINDOW_SIZE)
            .color(hsla(0.0, 0.0, 0.0, 0.1)); // 10% 불투명도
    }

    // 중앙 장애물 그리기 (투명한 원)
    draw.ellipse()
        .xy(pt2(0.0, 0.0))                 // 중심 좌표
        .radius(OBSTACLE_RADIUS)           // 반지름
        .color(hsla(0.0, 0.0, 0.0, 0.1));  // 매우 투명한 검정

    // 모든 입자 그리기
    for p in &model.particles {
        draw.ellipse()
            .xy(p.position)                // 입자 위치
            .radius(PARTICLE_RADIUS)       // 입자 크기
            .color(rgba(0.9, 0.9, 0.9, 0.5)); // 밝은 회색, 50% 투명
    }

    // GPU에 그리기 명령 제출
    draw.to_frame(app, &frame).unwrap();
}