hotwire/

lib.rs

//! # hotwire
//!
//! A Rust library for drawing drooping patch-cable wires using SDL3.
//!
//! ## Example
//!
//! ```rust,no_run
//! use hotwire::{WireLine, WireRenderer, WireParams};
//! use sdl3::pixels::Color;
//!
//! let sdl = sdl3::init().unwrap();
//! let video = sdl.video().unwrap();
//! let window = video.window("Wire Lines", 800, 600)
//!     .position_centered()
//!     .build()
//!     .unwrap();
//! let canvas = window.into_canvas();
//!
//! let mut renderer = WireRenderer::new(canvas);
//! let wire_line = WireLine::new(100.0, 300.0, 700.0, 300.0, WireParams::default());
//!
//! renderer.render(&wire_line, 0.0);
//! renderer.present();
//! ```

use noise::{NoiseFn, Perlin};
use rand::Rng;
use sdl3::pixels::Color;
use sdl3::render::{Canvas, FPoint};
use sdl3::video::Window;

/// Parameters controlling the wire appearance
#[derive(Debug, Clone, Copy)]
pub struct WireParams {
    /// Amount of sag/droop in the wire (in pixels)
    pub sag: f32,
    /// Thickness of the wire
    pub thickness: f32,
    /// Speed of subtle swaying animation
    pub sway_speed: f32,
    /// Amplitude of swaying motion
    pub sway_amount: f32,
    /// Density of wire segments
    pub segment_density: f32,
    /// Base color of the wire
    pub color: Color,
}

impl Default for WireParams {
    fn default() -> Self {
        Self {
            sag: 50.0,
            thickness: 3.0,
            sway_speed: 1.0,
            sway_amount: 5.0,
            segment_density: 2.0,
            color: Color::RGB(180, 180, 180),
        }
    }
}

/// Represents a wire that will be rendered with drooping effect
#[derive(Debug, Clone, Copy)]
pub struct WireLine {
    pub start: FPoint,
    pub end: FPoint,
    pub params: WireParams,
}

impl WireLine {
    /// Create a new wire line from coordinates and parameters
    pub fn new(x1: f32, y1: f32, x2: f32, y2: f32, params: WireParams) -> Self {
        Self {
            start: FPoint::new(x1, y1),
            end: FPoint::new(x2, y2),
            params,
        }
    }

    /// Get the horizontal distance of the line
    pub fn horizontal_distance(&self) -> f32 {
        (self.end.x - self.start.x).abs()
    }

    /// Get the vertical distance of the line
    pub fn vertical_distance(&self) -> f32 {
        self.end.y - self.start.y
    }

    /// Calculate the y position at parameter t (0 to 1) along the catenary curve
    fn catenary_y(&self, t: f32) -> f32 {
        let dy = self.end.y - self.start.y;

        // Linear interpolation for the straight-line component
        let linear_y = self.start.y + t * dy;

        // Parabolic droop (simpler than full catenary, looks good enough)
        // Maximum droop at t=0.5
        let droop = 4.0 * t * (1.0 - t) * self.params.sag;

        linear_y + droop
    }
}

/// Renderer for wire lines using SDL3
pub struct WireRenderer {
    canvas: Canvas<Window>,
    noise: Perlin,
}

impl WireRenderer {
    /// Create a new wire renderer with the given canvas
    pub fn new(canvas: Canvas<Window>) -> Self {
        Self {
            canvas,
            noise: Perlin::new(rand::rng().random()),
        }
    }

    /// Get a mutable reference to the canvas
    pub fn canvas_mut(&mut self) -> &mut Canvas<Window> {
        &mut self.canvas
    }

    /// Present the rendered frame
    pub fn present(&mut self) {
        self.canvas.present();
    }

    /// Render a wire line at the given time
    pub fn render(&mut self, line: &WireLine, time: f32) -> Result<(), String> {
        let horizontal_dist = line.horizontal_distance();
        let num_segments = (horizontal_dist * line.params.segment_density) as usize;

        if num_segments == 0 {
            return Ok(());
        }

        let dx = line.end.x - line.start.x;

        for i in 0..=num_segments {
            let t = i as f32 / num_segments as f32;

            // Base position along the catenary curve
            let x = line.start.x + t * dx;
            let base_y = line.catenary_y(t);

            // Add subtle swaying using noise
            let sway_offset = self.noise.get([
                x as f64 * 0.02,
                (time * line.params.sway_speed) as f64,
                0.0,
            ]) as f32 * line.params.sway_amount;

            let y = base_y + sway_offset;

            // Draw the wire segment with thickness
            for thickness_offset in 0..line.params.thickness as i32 {
                let offset = thickness_offset as f32 - line.params.thickness * 0.5;

                // Draw vertically offset points for thickness
                let py = y + offset;

                // Slightly vary color for cable texture
                let color_var = (self.noise.get([
                    x as f64 * 0.1,
                    py as f64 * 0.1,
                    1.0,
                ]) * 20.0) as i32;

                let r = (line.params.color.r as i32 + color_var).clamp(0, 255) as u8;
                let g = (line.params.color.g as i32 + color_var).clamp(0, 255) as u8;
                let b = (line.params.color.b as i32 + color_var).clamp(0, 255) as u8;

                self.canvas.set_draw_color(Color::RGB(r, g, b));
                self.canvas.draw_point(FPoint::new(x, py)).map_err(|e| e.to_string())?;
            }
        }

        Ok(())
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_wire_line_creation() {
        let line = WireLine::new(0.0, 0.0, 100.0, 0.0, WireParams::default());
        assert_eq!(line.start.x, 0.0);
        assert_eq!(line.start.y, 0.0);
        assert_eq!(line.end.x, 100.0);
        assert_eq!(line.end.y, 0.0);
    }

    #[test]
    fn test_wire_line_horizontal_distance() {
        let line = WireLine::new(0.0, 0.0, 100.0, 0.0, WireParams::default());
        assert_eq!(line.horizontal_distance(), 100.0);
    }

    #[test]
    fn test_catenary_y_midpoint() {
        let line = WireLine::new(0.0, 0.0, 100.0, 0.0, WireParams {
            sag: 50.0,
            ..WireParams::default()
        });

        // At t=0.5, we should have maximum droop
        let y_mid = line.catenary_y(0.5);
        assert!(y_mid > 0.0, "Wire should droop downward at midpoint");
    }

    #[test]
    fn test_catenary_y_endpoints() {
        let line = WireLine::new(0.0, 100.0, 100.0, 200.0, WireParams::default());

        // At endpoints, should match start/end y
        assert_eq!(line.catenary_y(0.0), 100.0);
        assert_eq!(line.catenary_y(1.0), 200.0);
    }
}