hotline 0.0.1

Draw lines that are on fire using SDL3
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96

use hotline::{FireLine, FireParams, FireRenderer};
use sdl3::event::Event;
use sdl3::pixels::Color;
use std::time::Instant;

fn main() -> Result<(), Box<dyn std::error::Error>> {
    // Initialize SDL3
    let sdl = sdl3::init()?;
    let video = sdl.video()?;

    // Create window
    let window = video
        .window("Hotline - Animated Example", 800, 600)
        .position_centered()
        .build()
        .map_err(|e| e.to_string())?;

    let canvas = window.into_canvas();
    let mut renderer = FireRenderer::new(canvas);

    // Create multiple fire lines
    let lines = vec![
        FireLine::new(
            100.0,
            200.0,
            700.0,
            200.0,
            FireParams {
                flame_height: 60.0,
                intensity: 1.0,
                flicker_speed: 2.0,
                particle_density: 1.0,
                flame_width: 20.0,
            },
        ),
        FireLine::new(
            150.0,
            350.0,
            650.0,
            350.0,
            FireParams {
                flame_height: 80.0,
                intensity: 1.2,
                flicker_speed: 3.0,
                particle_density: 1.2,
                flame_width: 30.0,
            },
        ),
        FireLine::new(
            200.0,
            500.0,
            600.0,
            500.0,
            FireParams {
                flame_height: 50.0,
                intensity: 0.8,
                flicker_speed: 1.5,
                particle_density: 0.8,
                flame_width: 15.0,
            },
        ),
    ];

    let mut event_pump = sdl.event_pump()?;
    let start_time = Instant::now();

    'running: loop {
        // Handle events
        for event in event_pump.poll_iter() {
            match event {
                Event::Quit { .. } => break 'running,
                _ => {}
            }
        }

        // Get elapsed time in seconds
        let time = start_time.elapsed().as_secs_f32();

        // Clear canvas
        renderer.canvas_mut().set_draw_color(Color::RGB(0, 0, 0));
        renderer.canvas_mut().clear();

        // Render all fire lines with animation
        for line in &lines {
            renderer.render(line, time)?;
        }

        // Present
        renderer.present();

        // Small delay
        std::thread::sleep(std::time::Duration::from_millis(16));
    }

    Ok(())
}